server con thread

[cicerone]

Ciao a tutti!
sto scrivendo una applicazione client server in java per un gioco in rete.
fino ad ora mi sono concentrato sul client ed ho usato un server minimale.
questo server accetta due connessioni ( player1 e player2 )
rimette in output sui due client esattamente ciò che ogni singolo client invia.
ora vorrei che ad ogni coppia di connessioni si creasse un thread con comportamento analogo,
che il server sia cioè sempre libero.
in pratica ora il server una volta attivato ospita una sola partita tra due giocatori.
io voglio che sua sempre running ( senza spegni e riaccendi ) e che possano svolgersi piu partite in contemporanea.
qualche idea?

 

public class ChatServer {

    public static void main(String[] args) throws Exception {

	ServerSocket serverSocket             = new ServerSocket(4444);
        
	System.err.println("Server started.\n In attesa del primo client...");
    	Socket clientSocket1 = serverSocket.accept();
       	System.err.println("Created socket with client" + clientSocket1.toString() );        
	Connection connectionA        = new Connection( clientSocket1 );
	connectionA.start();

	System.err.println("In attesa del secondo client...");
    	Socket clientSocket2 = serverSocket.accept();
       	System.err.println("Created socket with client" + clientSocket2.toString() );        
	Connection connectionB        = new Connection( clientSocket2 );
        connectionB.start();

	ConnectionListener connectionListener = new ConnectionListener( connectionA , connectionB );

        // thread that broadcasts messages to clients
        connectionListener.start();// start chiama il run del thread
	System.err.println("Inizio della comunicazione");
	
    
}
}


public class ConnectionListener extends Thread {
    private Connection connectionA;
    private Connection connectionB;

	
    public ConnectionListener(Connection a ,  Connection b) {
        this.connectionA = a;
	this.connectionB = b;
    }

    // check for incoming messages and broadcast
    public void run() {
	
	                connectionA.println("Player1\n");
			connectionB.println("Player2\n");
        while (true) {


                // broadcast to everyone
                String message = connectionA.getMessage();
                if (message != null  )
                    {
                        connectionA.println(message);
			connectionB.println(message);
			}			
            	message = connectionB.getMessage();
                if (message != null  )
                    {
                        connectionB.println(message);
			connectionA.println(message);
			}

            // don't monopolize processor
            try                 { Thread.sleep(100);   }
            catch (Exception e) { e.printStackTrace(); }
        }
    }

}



public class Connection extends Thread {
    private Socket socket;
    private Out out;
    private In in;
    private String message;     // one line buffer

    public Connection(Socket socket) {
        in  = new In(socket);
        out = new Out(socket);
        this.socket = socket;
    }

    public void println(String s) { out.println(s); }

    public void run() {
        		String s;
        		while ((s = in.readLine()) != null) 
			{
            			setMessage(s);
        		}
        	out.close();
        	in.close();
        	try                 { socket.close();      }
        	catch (Exception e) { e.printStackTrace(); }
        	System.err.println("closing socket");
    }


   /*********************************************************************
    *  The methods getMessage() and setMessage() are synchronized
    *  so that the thread in Connection doesn't call setMessage()
    *  while the ConnectionListener thread is calling getMessage().
    *********************************************************************/
    public synchronized String getMessage() {
        if (message == null) return null;
        String temp = message;
        message = null;
        notifyAll();
        return temp;
    }

    public synchronized void setMessage(String s) {
        if (message != null) {
            try                  { wait();               }
            catch (Exception ex) { ex.printStackTrace(); }
        }
        message = s;
    }

}

[VincenzoTheBest]

In questo caso penso sia meglio strutturare l'architettura dell'applicazione come semi-p2p, cioè nel momento in cui un player ha trovato il suo avversario, allora uno dei due fa da server e l'altro da client (ed eventualmente solo uno dei due mantiene la connessione con il server principale, solo se necessario: ad esempio se il server vuole sapere il risultato della partita per fini statistici e quindi lo registra nel suo dataset).

Altrimenti la implementi come client-server dove ogni thread (processo di un giocatore) salva il flusso di dati in uscita/output del suo avversario in modo tale che il server, nel momento in cui riceve qualcosa da un determinato giocatore, sa chi è il suo avversario e dunque recapita correttamente i dati ricevuti.

[cicerone]

grazie per la risposta! l'idea del p2p mi piace ma ho risolto nel frattempo con una nuova classe che chrea il chatserver ogni volta che si presentano due connessioni dal client. ora chatserver implementa i thread e in questa nuova classe c'è un ciclo while infinito! se a qualcuno interessa posto il codice! ciao e grazie di nuovo!!