java - servidor - threads y sockets

¿Cómo hacer que múltiples hilos usen el mismo socket para leer y escribir?

Question

**

Habrá múltiples clientes que envíen mensajes al servidor en el puerto 6069. Estoy tratando de manejar múltiples solicitudes al mismo tiempo, pero no estoy seguro de que el código a continuación pueda hacerlo.

Habrá solicitudes en la cola del socket. Como solo hay un hilo, ejecutará su iteración en una solicitud y luego tomará la siguiente solicitud de la cola. ¿Cómo puedo atender a varios clientes al mismo tiempo?

**

Este es el hilo de creación de clase para escuchar en el puerto 6069.

public class NetworkModule extends Thread {
  private ServerSocket serverSocket;

  public NetworkModule(int port) throws IOException {

    serverSocket = new ServerSocket(port);
  }

    public void run() {
      while (true) {

                /* Here I read strings from the inputstream and write
                  to outputstream corresponding to "serverSocket" and call
                functions from other classes*/
      }
    }

}

a continuación se muestra cómo se ve la clase principal

public class Main
{

   public static void main(String[] args) 
   {
       try
          {
            int port=6069;
             Thread t = new NetworkModule(port);
             t.start();

          }
       catch(IOException e)
          {
             e.printStackTrace();
          }

   }

}

Answer 1

¡Esa no es una buena manera de escribir un programa de servidor!
será mejor que tengas dos clases:

• 1) client_handler:
  una clase que maneja a los clientes y es responsable de atender a los clientes. vamos a llamarlo client_handler.java.
  Se debe crear un objeto de esta clase para cada cliente conectado al servidor.
  Los clientes deben obtener servicios en paralelo, por lo tanto, esta clase debe extender Thread o implementar la interfaz Runnable .

• 2) Servidor: ¡ otra clase que espera que los clientes se conecten! Vamos a nombrarlo: server.java
  esta clase implementará el método main !
  la clase de servidor debe crear un nuevo hilo en cada conexión, para que los clientes puedan obtener servicios en paralelo.
  **********************************
  a continuación, hay un código para demostrar las cosas que dije anteriormente:
  

  /*this is the server class i talked about : */
  public class server{
     static void main (String args[]){
          ServerSocket ss = new ServerSocket (args[0]);
          while (true){
              Socket  s =  ss.accept();
              client_handler ch = new client_handler(s);
              Thread t = new Thread(ch);
              t.start();
          }
      }
  
  }

y aquí hay un código de muestra para client_handler:

public class client_handler implements Runnable{
    private Socket s ;
    private Scanner in ;
    print PrintWriter out;

    public client_handler(Socket s){
        this.s =s;
        in= new Scanner(s.getInputStream());
        out= new PrintWriter(s.getOutputStream());        
    }

   public void run(){
      // this is the entry of your thread . 
      // you can analyse the request received here . and send responses !

   }
}

Answer 2

Debe cambiar su código de tal manera que proporcione acceso desde el lado del servidor para que más clientes puedan acceder (procesar) los datos enviados a través del puerto 6069. Su aplicación cliente que es la segunda es simplemente simple con lógica implementada para conectarse al servidor activo (si corresponde) o basado en algunas reglas, etc.). La aplicación de servidor hace que la magia para proporcionar acceso. Esto significa que cada cliente vea cada mensaje enviado por otros clientes y viceversa.

Creo que es útil leer: Knock Knock Protocol . Le explicará mucho cómo se manejan las cosas y funcionan en su caso.

Answer 3

Si puede aislar el método de manejo del cliente, diga en una nueva clase ClientHandler que también amplíe Thread where in run() que lee y escribe en streams. Luego, en su run() de NetworkModule :

while (true) {
     Socket socket = serverSocket.accept(); // blocks until new client connects
     ClientHandler handler = new ClientHandler(socket); // pass reference to socket
     handler.start(); // start executing in new thread
}

En general, es mejor implement Runnable lugar de extending Thread , porque puede implementar muchas interfaces, pero se extiende solo desde una sola clase, debido al modelo de herencia de Java.