serveur de gestion de nombreux clients java

Question

les gars! J'ai écrit l'application simple de client de serveur (UDP). Maintenant j'essaye de faire le serveur qui accepte beaucoup de clients. Comme, j'ai compris, j'ai besoin de créer des fonctions, qui accepte et gère les clients, mais je suis confus au sujet de la structure des applications. Pouvez-vous vérifier si j'ai le bon squelette pour mon application? Mayb vous pouvez me donner un indice ou un exemple. Tous les conseils ont été appréciés! :)

class MultiServer { 

    private DatagramSocket serversocket; 

    public MultiServer() { 
     try { 
      this.serversocket = new DatagramSocket(6789); 
     } catch (IOException e) { 
      // TODO Auto-generated catch block 
      e.printStackTrace(); 
     } 
    } 

    public void start() throws IOException { 
     while(true) { 
      DatagramSocket serversock = serversocket.accept(); 
      new Thread(new ClientHandler(serversock)).start(); 
     } 
    } 

    public static void main(String[] args) { 
     Server1 server = new Server1(); 
     try { 
      server.start(); 
     } catch (IOException e) { 
      // TODO Auto-generated catch block 
      e.printStackTrace(); 
     } 

    } 
} 

class ClientHandler implements Runnable { 

     private final DatagramSocket clientsocket; 

     ClientHandler(DatagramSocket sock) { 
      this.clientsocket = sock; 
     } 

     @Override 
     public void run() { 
      //receive packet, send msg, get ip, get portnumber ? 
     } 

    } 

} 

Answer 1

Vous recherchez un serveur Threadpooled. La façon dont vous avez commencé est bonne. Maintenant, vous implémentez simplement un service d'exécution Java pour gérer les requêtes. Le pool de threads a une partie fixe de thread. Il prend vos demandes et les met dans une file d'attente et si une demande est faite, il prend la demande suivante. Donc, vous ne perdez normalement aucune demande.

Voici un petit exemple je l'ai fait:

public class PoolServer implements Runnable { 
    private static final int DEFAULT_PORT = 8080; 
    private static final String CONFIG = "config.xml"; 
    protected ServerSocket serverSocket = null; 
    protected boolean isStopped = false; 
    protected Thread runningThread = null; 
    protected ExecutorService threadPool = Executors.newFixedThreadPool(100); 
    protected int serverPort; 

    public PoolServer() { 
     // getting the port from the XML 
     this.serverPort = getPortFromXML(); 
    } 

    public void run() { 
     synchronized (this) { 
      this.runningThread = Thread.currentThread(); 
     } 
     openServerSocket(); 
     // accepting loop 
     while (!isStopped()) { 
      Socket clientSocket = null; 
      try { 
       // accept the client 
       clientSocket = this.serverSocket.accept(); 
       clientSocket.setSoTimeout(2000); 

      } catch (IOException e) { 
       if (isStopped()) { 
        return; 
       } 
       throw new RuntimeException("Error accepting client connection", 
         e); 
      } 
      this.threadPool.execute(new ThreadHandler(clientSocket)); 
     } 
     // loop end 
     // server stopped shut down the ThreadPool 
     this.threadPool.shutdown(); 
    } 

    private synchronized boolean isStopped() { 
     return this.isStopped; 
    } 

    public synchronized void stop() { 
     this.isStopped = true; 
     try { 
      this.serverSocket.close(); 
     } catch (IOException e) { 
      throw new RuntimeException("Error closing server", e); 
     } 
    } 

    private void openServerSocket() { 
     try { 
      this.serverSocket = new ServerSocket(this.serverPort); 
     } catch (IOException e) { 
      throw new RuntimeException("Cannot open port " + this.serverPort, e); 
     } 
    } 

À ce stade this.threadPool.execute(new ThreadHandler(clientSocket)); je fais exécuter la demande si un thread est libre. Sinon, entrez dans la file d'attente du Threadpool.

Vous pouvez même le changer d'un Fixe à d'autres Threadpools! Jetez un coup d'œil aux exécuteurs et prenez ce dont vous avez besoin. Executors
Espérons que cela aide!

Answer 2

Vous voulez donc que votre serveur puisse fonctionner avec plusieurs demandes en même temps? Bon, c'est comme ça que fonctionnent la plupart des serveurs web. Vous devez comprendre les concepts de base du multi-threading et de la concurrence. Un serveur simple ne peut gérer qu'une seule chose à la fois. Que se passe-t-il si une autre requête est reçue alors que le serveur traite quelque chose d'autre? Rien, donc l'application n'est pas très efficace et pas évolutive du tout.

Si vous n'avez pas encore utilisé plusieurs threads dans vos applications et que vous ne connaissez pas grand-chose à la concurrence, c'est un bon moment pour y aller, lisez le Oracle Concurrency Lesson, ou trouvez un tutoriel en ligne, il y en a plein. Maintenant, une fois (ou si) vous savez comment fonctionne le filetage, assurez-vous de décomposer vos fonctions autant que possible et de voir quelles fonctions peuvent se produire en même temps. Un exemple de serveur Web auquel je peux penser est celui-ci:

• Un thread séparé pour écouter sur le port pour les demandes. Une fois qu'une demande est reçue, le placer dans la « demande pool » et la file d'attente pour être traité
• Un fil distinct (ou plusieurs threads/pool de threads) qui traite la demande

la structure vous semble avoir Les deux reçoivent et traitent dans le même Runnable. Quoi qu'il en soit, c'est juste une idée, vous devrez voir ce qui est plus applicable à votre application. Jetez également un coup d'œil sur les outils de simultanéité fournis par les versions Java les plus récentes. Java 6 et 7 offrent de nombreux outils très efficaces (mais également très difficiles à comprendre et à utiliser à mon avis).

Bonne chance!