JAVA: creare server che non blocca il thread chiamante

[albe82]

Ciao!
ho fatto un piccolo server che fa due stupidate messe in croce (praticamente data una stringa, la converte in maiuscolo).
Il passo successivo è stato quello di renderlo multitrhead, in modo tale da far collegare più client alla volta.....
Ora vorrei fare questo....vorrei praticamente aprire contemporaneamente più server su porte diverse, ma il mio problema risiede nel fatto che quando invoco il metodo go(), ovviamente questo blocca il chiamante e non mi fa partire gli altri server....
se qualcuno può darmi una mano...
posto qui di seguito il codice

package serverthreaded;

/**
 *
 * @author Albe
 */
import java.net.*;
import java.io.*;
import java.util.*;

public class ServerThreaded_1 {
    int port1 = 7979;
   // int port2 =7000;

	public ServerThreaded_1(int p)  {
       port1 = p;
     //  port2 = p;
	}

/**
 *  It never terminates.
 */
	public void go() throws IOException {
      ServerSocket s = new ServerSocket(port1);
//ServerSocket k = new ServerSocket(port2);
      System.out.println("Multithreaded Server started on port " + port1);
   //   System.out.println("Multithreaded Server started on port " + port2);
      Socket client = null;

      while (true) {
          try {
              client = s.accept();
              Thread t = new ServerHandler(client);
              t.start();
          }
          catch (IOException e) {
               if (client != null)
                  client.close();
          }
      }
    }

public static void main(String args[]) throws IOException {
      ServerThreaded_1 srv = new ServerThreaded_1(7979);     
    //  ServerThreaded_1 srv1 = new ServerThreaded_1(7000);
     srv.go(); 
 //    srv1.go();
}

}
class ServerHandler extends Thread  {
      Socket cln;

      ServerHandler(Socket c)  {cln = c;}

      public void run() {
          BufferedReader in = null;
          PrintStream out = null;
          Date prima = new Date();
	    System.out.println("Connessione avvenuta alle ore: " + prima.toString());
          try {
              in = new BufferedReader(
                   new InputStreamReader(
                       cln.getInputStream()));
              out = new PrintStream(cln.getOutputStream());

              boolean done = false;
              while(! done) {
                      String str = in.readLine();
                      if (str == null)
                         done = true;
                      else {
                           String str1 = str.toUpperCase();
                           out.println(str1);
                           if(str1.equals("END"))
                               done = true;

                      }                      
              }  	Date dopo = new Date();
				System.out.println("Disconnessione avvenuta alle ore: " + dopo.toString());
          }
          
             
          
          catch (IOException e) {
                System.out.println("Server thread exiting because of IOException...");
          }
          finally  {
                   try { out.close(); in.close();
                   }
                   catch (IOException e) {
                   }
          }

      }

}

io quindi nel main vorrei poter fare qualcosa del genere:

ServerThreaded_1 srv = new ServerThreaded_1(7979);
ServerThreaded_1 srv1 = new ServerThreaded_1(7000);
ServerThreaded_1 srv2 = new ServerThreaded_1(9000);
ServerThreaded_1 srv3 = new ServerThreaded_1(9999);
srv.go();
srv1.go();
srv2.go();
srv3.go();

...e così via.....
Grazie ancora!

[Stoicenko]

il forum di java non è qui.. comunque...

devi crearti una classe che erediti da thread e implementare run oppure implementare runnable..

in poche parole ogni oggetto ServerThreaded deve essere un thread o deve implementare runnable in modo che la sua Run (la tua go) non sia bloccante per il main..

Sulla documentazione ufficiale della sun su java (che dovresti sempre consultare) c'è scritto tutto su come usare i thread

[albe82]

ops....
cmq grazie! ora provo!

[LeleFT]

Spostato nel forum corretto.


Ciao.

[@DI3GO@]

La soluzione possibile è questa....Tu crei un Thread per ogni istanza server che desideri, quindi se vuoi creare 4 server in ascolto, dovrai creare 4 Thread dentro i quali ( ogni singolo Thread ) avrà una accept bloccante e di conseguenza tutto l'ambaradam che vuoi far fare ad ogni singolo server.
Non devi prendere il Thread principale e lanciarci la accept, in questo modo, come ti è capitato, fino a che non riceve una nuova connessione non vengono istanziati gli altri server.
Invece crea un nuovo Thread per ogni server che vuoi istanziare, poi all'interno del Thread_server chiami la funzione accept, ed una volta che hai ottenuto la connessione chiami il Thread_client che gestisce la comunicazioni ( in modo indipendente e non bloccante ) di ogni singolo client....
Spero di esser stato chiaro.

[matthew80]

Sarà che son tonto, ma non ho capito una cosa.
Suppongo tu utilizzi i socket e quindi vuoi creare un Server ed un Client che dialogano attraverso dei Socket.
Ora, rendere un Server multithread significa fare in modo che questo Server possa accettare connessioni, e quindi richieste, da diversi Client.
Una soluzione di questo tipo, abbastanza classica, non si implementa certo creando più Server in ascolto su porte diverse. Infatti in quel caso si parla di 4 Server separati sempre però Single-Thread!
La soluzione classica è quella di creare un singolo Server Mutithread che resta in ascolto sempre sulla stessa porta.

Ecco un esempio di Server MultiThread che accetta connessioni simultanee da diversi Client contemporaneamente

import java.net.*;
import java.io.*;

public class SimpleServer {
    private int port;
    private ServerSocket server;
    private Socket client;

    public SimpleServer(int port) {
        this.port = port;
        if (!startServer())
            System.err.println("Errore durate la creazione del Server");
    }

    private boolean startServer() {
        try {
            server = new ServerSocket(port);
        } catch (IOException ex) {
            ex.printStackTrace();
            return false;
        }
        System.out.println("Server creato con successo!");
        return true;
    }

    public void runServer() {
        while (true) {
            try {
                // Il server resta in attesa di una richiesta
                System.out.println("Server in attesa di richieste...");
                client = server.accept();
                System.out.println("Un client si e' connesso...");
                ParallelServer pServer = new ParallelServer(client);
                Thread t = new Thread(pServer);
                t.start();
            } catch (IOException ex) {
                ex.printStackTrace();
            }
        }
    }

    public class ParallelServer implements Runnable {
        private Socket client;

        public ParallelServer(Socket client) {
            this.client = client;
        }

        public void run() {
            try {
                // Ricava lo stream di output associate al socket
                // e definisce una classe wrapper di tipo
                // BufferedWriter per semplificare le operazioni
                // di scrittura
                OutputStream s1out = client.getOutputStream();
                BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(
                        s1out));

                // Il server invia la risposta al client
                bw.write("Benvenuto sul server!\n");

                // Chiude lo stream di output e la connessione
                bw.close();
                client.close();
                System.out.println("Chiusura connessione effettuata");
            } catch (IOException ex) {
                ex.printStackTrace();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String args[]) {
        SimpleServer ss = new SimpleServer(7777);
        ss.runServer();
    } 

Ti ricordo inoltre che il costruttore della classe ServerSocket ha anche una versione per limintare il numero di Client che possono collegarsi al Server.
Ecco un esempio su come limitare a 5 il numero di Client che possono collegarsi al Server contemporaneamente:

ServerSocket server = new ServerSocket(7777, 5); 

Spero di aver capito bene le tue intenzioni e di non averti dato informazioni che non ti servivano

Ciao,
Matteo.

[@DI3GO@]

Originariamente scritto da albe82
...vorrei praticamente aprire contemporaneamente più server su porte diverse, ma il mio problema risiede nel fatto che quando invoco il metodo go(), ovviamente questo blocca il chiamante e non mi fa partire gli altri server....

Con questo dici di voler diversi server su diverse porte....Quindi se vuoi che tutti i server siano contemporaneamente attivati e pronti ad ascoltare devi gestirli in Thread differenti.

Se invece vuoi che una volta riempito il server1 passo al server2 e così via la questione cambia.

La variabiel ParallelServer non mi sembra identifichi correttamente la sua funzione...
infatti una volta che il server ottiene risposta dal metodo bloccante accept() io istanzio un canale di comunicazione con il cliente ( Socket ) e non viene istanziato un nuovo server.

Se intendo accettare più connessione ( ipoteticamente infinite ) sullo stesso serverSocket basta inserire la accept() all'interno di un ciclo infiniro ( o con controlli a tua scelta ) i modo che una volta istanziata un canale Socket di comunicazione con il client intercettato ritorni ad eseguire la accept() e tranquillo, senza generare nessun problema.

Se non ho capito perdonami, ma ci ho provato.
Semmai non postare codice, ma spiegami per bene le tue intenzioni.

[matthew80]

@DI3GO@ vorrei segnalarti che la citazione che mi hai affidato...non è mia, bensì di albe82!

Il problema, secondo me è che albe82 vuole adottare soluzioni esotiche per problemi invece tutto sommato classici. Mi spiego meglio.
All'inizio di questo thread albe82 dice:

ho fatto un piccolo server [...] Il passo successivo è stato quello di renderlo multitrhead, in modo tale da far collegare più client alla volta

Per farlo vorrebbe creare più Server single-thread in ascolto su diverse porte e la discussione sta vertendo su come implementare una cosa simile.
Il fatto è che non si risolve in questo modo il problema, bensì creando un Server Multithread che accetta richieste da più Client.

Il codice che ho postato è proprio quello di un Server Socket MultiThread che accetta richieste da diversi Client, quindi la soluzione più lineare al problema.
Speriamo che albe82 possa darci maggiori delucidazioni su quali sono le sue intenzioni, cosicchè riusciamo a capire che cosa vuole fare esattamente.

[albe82]

Rieccomi! intanto GRAZIE a tutti per le risposte veloci e complete che mi avete dato....
@ matteo...
allora....attualmente il mio programmino fa partire 1 server, a cui si possono collegare infiniti client...e tutto funziona....

quello che vorrei fare io è quello che ha specificato Diego...ovverooo

Con questo dici di voler diversi server su diverse porte....Quindi se vuoi che tutti i server siano contemporaneamente attivati e pronti ad ascoltare devi gestirli in Thread differenti.

Ora quindi dovrei farmi una classe ServerThreaded_1 che " extends thread ", (credo)...

Io praticamente voglio che il mio programma apra N server su N porte differenti, e che ciascun server gestisca M client (questa parte, per un solo server, la ho già fatta).

Spero di aver chiarito lievemente le cose......e vi ri-ringrazio

[@DI3GO@]

@matthew80
Risolto il disguido...Scusa.

@albe82.
Allora è come avevo intuito....
Come detto prima e come hai ripetuto tu:

Scritto da albe82
Ora quindi dovrei farmi una classe ServerThreaded_1 che " extends thread ", (credo)...

Io praticamente voglio che il mio programma apra N server su N porte differenti, e che ciascun server gestisca M client (questa parte, per un solo server, la ho già fatta).

Per il numero limitato di Client utilizzi l'istanza di ServerSocket( porta , max_utenti ), mentre per aprire contemporaneamente più server devi lanciare N Thread che gestiscono N Server, ed ogni server verrà gestito come l'implementazione del singolo server che hai fatto sino ad ora....

Forse ci siamo!!!