[JAVA] GUI per Server Multithread

[fbcyborg]

Ciao!
ho finalmente ultimato il mio server FTP multithread. Adesso è arrivata l'ora di "agganciare" ad esso la GUI.
Non so come risolvere un problema di fondo.
La gui presenta un bottone per la connessione e un bottone per la disconnessione.
Come tutti sanno il lato server ha la struttura:

ServerSocket server = new ServerSocket(serverPort);
Socket welcomeSocket;
while(true){
    welcomeSocket = server.accept();
    ..... // start del thread...
}

Ora, il problema è che il bottone per la connessione in questione, servirebbe per "attivare" il server, e per metterlo in ascolto sulla porta serverPort. Stiamo quindi parlando del Socket per la connessione di controllo.
Il problema è che quando la gui richiama il metodo per la connessione, poi il programma si alluppa nel ciclo sopra riportato, impallando quindi anche la GUI.
Non so come fare per "separare" i due processi... La gui si deve limitare a mettere in ascolto il server, e non deve aspettare che la classe contenente il ciclo appena scritto sopra termini, poichè attenderebbe inutilmente.

Come posso fare?

[fek]

Metti il ciclo di accept in un altro thread che fa da Boss, in una configurazione Boss-Worker. I Worker sono i thread che si occupano delle connessioni, il Boss si occupa di fare l'accept e smistare il lavoro.

Un'altra soluzione (che puo' essere usata assieme a questa che ti ho detto) e' usare socket "non bloccanti". Invece di bloccare l'esecuzione sull'accept, fai un "polling" sul socket, chiedendo ad ogni ciclo se e' disponibile una connessione, se lo e' crei un thread, altrimenti ripeti il ciclo in una forma di questo tipo (pseudo codice):

  while (!QuitServer())
  {  
    if (IsConnectionAvailable())
    {
       thread = CreateThread();
       thread.HandleConnection();    
    }
    
    ReleaseCPUToAnotherThread();
  }

  WaitForAllConnectionsToFinish();

IsConnectionAvailable() non e' bloccante e ritorna true se c'e' una connessione in ingresso, altrimenti ritorna subito false. Guarda la documentazione Java per usare socket non bloccanti.

La GUI puo' lanciare il thread del server e impostare una flag testata da QuitServer() quando il thread del server deve fermarsi.

[fbcyborg]

MMh... benone..
innanzitutto ti ringrazio per avermi risposto, e soprattutto in modo così dettagliato. Premetto che non ho mai sentito parlare di questa tecnica Boss-Worker, ne tantomeno ho mai sentito parlare di Socket non bloccanti.
Dovrò quindi mettermi a studiare tali sistemi per poi apportare le dovute modifiche. Ti farò sapere... grazie ancora.

[fek]

Originariamente inviato da fbcyborg

MMh... benone..
innanzitutto ti ringrazio per avermi risposto, e soprattutto in modo così dettagliato. Premetto che non ho mai sentito parlare di questa tecnica Boss-Worker, ne tantomeno ho mai sentito parlare di Socket non bloccanti.
Dovrò quindi mettermi a studiare tali sistemi per poi apportare le dovute modifiche. Ti farò sapere... grazie ancora.

Piacere mio

Boss-Worker non e' nulla di trascendentale, e' quello che hai gia' fatto.

Un thread si occupa solo di smistare il lavoro, nel tuo caso il thread principale, ma ne puoi creare un altro, e si chiama Boss.
I thread creati che svolgono il lavoro vero e proprio si chiamano Worker. Quando finiscono il lavoro terminano o vanno in Sleep aspettando di vedersi assegnato del nuovo lavoro da svolgere dal Boss.

Qui trovi del codice in Java per creare un server non bloccante:

http://www.onjava.com/pub/a/onjava/2...io.html?page=2

E' un po' complesso, devo dire che in C# e' decisamente piu' semplice.

[Alvaro Vitali]

Ma in Java non c'è qualcosa di di simile alla "select" delle socket di Berkeley ?
E' usata per fare server del tipo "concorrente singolo-processo" , poteva essere comoda in questo caso...

[71104]

Originariamente inviato da Alvaro Vitali

Ma in Java non c'è qualcosa di di simile alla "select" delle socket di Berkeley ?

no, o almeno non mi sembra: in Java mi pare che le chiamate dei socket ti bloccano il thread; ad es. se devi ricevere dati, tu chiami il relativo metodo, e il tuo thread viene bloccato finché non ci sono dati disponibili; analogamente si lavora per un listener che deve accettare connessioni. invece per sapere quando il socket dall'altro capo ha chiuso, devi intercettare un'eccezione che non ricordo.

[fbcyborg]

Dunque... nel frattempo ho trovato questo sistema:

onlineButton.addActionListener(new java.awt.event.ActionListener() { 
				public void actionPerformed(java.awt.event.ActionEvent e) {    
						new Thread("Server starter") {
							public void run() {
								try{
									FTPServerMultiThread.connect();
								}catch (Exception ex){}
							}
						}.start();
					
					onlineButton.setEnabled(false);
					offlineButton.setEnabled(true);
				}
			});

In questo modo, premendo il bottone onlineButton parte un thread che utilizza un metodo della classe FTPServerMultiThread che mette il server in ascolto.
Ho fatto la stessa cosa per il bottone offlineButton, ma ovviamente, la connessione non viene interrotta poichè i due thread non sono "comunicanti".
Quindi ora mi rimarrebbe il problema della disconnessione.

Per quanto riguarda i socket non bloccanti, non ha importanza, sto facendo un progetto per l'università, e devo usare quello che mi hanno insegnato.

[fbcyborg]

Penso di aver risolto inserendo un
Thread.yield() dopo lo start().

ora funziona tutto;

PORCA MISERIA
ora invece non funziona proprio una mazza!!!!!
prima andava!

[fbcyborg]

Dunque:
il mio software a grandi linee è così strutturato:

public class Server{

____private ServerSocket server

____public static void connect() throws IOException{
________server = new ServerSocket(21);
________Socket connectionSocket;
________while(true){
____________connectionSocket = server.accept();
____________new ClientHandler(connectionSocket).start();
________}
____}

____publi c static void offline() throws IOException{
________server.close();
____}
}

// Classe principale dell'applicazione:
public class ClientHandler extends Thread{
____private Socket connectionSocket;

____public ClientHandler(Socket clientSocket){
________connectionSocket = clientSocket;
____}

____public void run(){
________/* quì ci sono tutti i vari cicli while
_________* che servono a chiamare le varie funzioni
_________* del programma */
____}

____public void doPut(){}

____public void doGet(){}

____//ecc....
}

// Parte grafica:

public class GUIServer extends JFrame{
____public GUIServer();

____public static void main(String[] args);

____private void initialize();

____private void getOnlineButton{
________// vari metodi x inizializzare
____onlineButton.addActionListener(new ____java.awt.event.ActionListener() {
________public void actionPerformed(java.awt.event.ActionEvent e) {
____________new Thread("Server starter") {
________________public void run() {
____________________try{
________________FTPServerMultiThread.connect();
____________________}catch (Exception ex){}
________________}
____________}.start();
/*ho provato a mettere uno stop() (deprecato) o uno yield() da queste parti ma non funzona bene.
____________onlineButton.setEnabled(false);
____________offlineButton.se tEnabled(true);
________}
____});
____}
}

IDEM per l'offline Button, duale all'online Button.

Questo è quanto, spero sia sufficiente per meglio chiarire la situazione

[wireless]

scusa, sta preparando l'esame di sistemi operativi 2 con crescenzi?:-D

[fbcyborg]

NO! magari fossero queste le cose x sistemi operativi 2!!!!!

cmq crescenzi non lo conosco... io sto alla sapienza. e tu?

[fbcyborg]

Per fek:

Originariamente inviato da fek

Piacere mio

Boss-Worker non e' nulla di trascendentale, e' quello che hai gia' fatto.

Un thread si occupa solo di smistare il lavoro, nel tuo caso il thread principale, ma ne puoi creare un altro, e si chiama Boss.
I thread creati che svolgono il lavoro vero e proprio si chiamano Worker. Quando finiscono il lavoro terminano o vanno in Sleep aspettando di vedersi assegnato del nuovo lavoro da svolgere dal Boss.

Qui trovi del codice in Java per creare un server non bloccante:

http://www.onjava.com/pub/a/onjava/2...io.html?page=2

E' un po' complesso, devo dire che in C# e' decisamente piu' semplice.

Dunque... ho dato un'occhiata, ed effettivamente è un po' complesso, se non un po' ardua come impresa per adattarlo al mio progetto... Vediamo se ho capito bene... Il mio Server funziona in questo modo come già sai: classe con main che ad ogni richiesta di connessione avvia un thread. Fin quì ci siamo. Come dovrei collegare questi nuovi thread alla classe con il metodo main (che poi tramuterò in metodo connect() per interfacciarlo con la gui) affinchè facciano quello che mi serve? Dici che ne dovrei creare un altro, un Boss, ok, ma non ho idea di cosa fare di preciso....

[fek]

Originariamente inviato da fbcyborg

Per fek:


Dunque... ho dato un'occhiata, ed effettivamente è un po' complesso, se non un po' ardua come impresa per adattarlo al mio progetto... Vediamo se ho capito bene... Il mio Server funziona in questo modo come già sai: classe con main che ad ogni richiesta di connessione avvia un thread. Fin quì ci siamo. Come dovrei collegare questi nuovi thread alla classe con il metodo main (che poi tramuterò in metodo connect() per interfacciarlo con la gui) affinchè facciano quello che mi serve? Dici che ne dovrei creare un altro, un Boss, ok, ma non ho idea di cosa fare di preciso....

Pensa alla soluzione piu' semplice che ti possa venire in mente

Hai il ciclo di accept del server nel main. Ti serve spostarlo in un alro thread. Quindi?

[fbcyborg]

il primo pensiero che mi viene in mente se mi dici così.... è quello di fare un extends Thread per la classe Server e mettere il while nel metodo run().
ma sinceramente sono andato un po' nel pallone...
sarà il caldo, la voglia di mare, ma non saprei proprio...
.. ma poi per chiudere il ServerSocket?

oppure mettere ciò che sta nel main nella classe della GUI?
mi sembra di averci provato.. forse ho sbagliato qualcosa

[fek]

Originariamente inviato da fbcyborg

il primo pensiero che mi viene in mente se mi dici così.... è quello di fare un extends Thread per la classe Server e mettere il while nel metodo run().

Prova. E ricorda, prova sempre la soluzione piu' semplice che pensi risolva il problema che hai di fronte. Non preoccuparti per ora di quello che puo' succedere dopo.

ma sinceramente sono andato un po' nel pallone...
sarà il caldo, la voglia di mare, ma non saprei proprio...
.. ma poi per chiudere il ServerSocket?

Ci penserai dopo
Un problema per volta.

oppure mettere ciò che sta nel main nella classe della GUI?
mi sembra di averci provato.. forse ho sbagliato qualcosa

Separa sempre la GUI dalla logica dell'applicazione.

[fbcyborg]

Ok, ho provato... però sulla gui succede questo:
alla pressione di un bottone per andare online, viene avviato il thread, che esegue il metodo run(). In questo metodo c'è il while true per accettare le connessioni. Ora però, non riesco a stoppare il thread(questo è l'unico modo che mi è venuto in mente per chiudere il ServerSocket) perchè non so come "acchiapparlo". Non ho un thread id come in C che posso decidere di terminare a mio piacimento... o almeno non ci riesco. il metodo offline() l'ho commentato....
ho provato anche con la funzione Thread.currentThread(), ma non mi fa fa re lo stop() (tra l'altro deprecato) di quel thread.
Rimane quindi il solito problema della connessione aperta.

[fek]

Originariamente inviato da fbcyborg

Ok, ho provato... però sulla gui succede questo:
alla pressione di un bottone per andare online, viene avviato il thread, che esegue il metodo run(). In questo metodo c'è il while true per accettare le connessioni. Ora però, non riesco a stoppare il thread(questo è l'unico modo che mi è venuto in mente per chiudere il ServerSocket) perchè non so come "acchiapparlo". Non ho un thread id come in C che posso decidere di terminare a mio piacimento... o almeno non ci riesco. il metodo offline() l'ho commentato....
ho provato anche con la funzione Thread.currentThread(), ma non mi fa fa re lo stop() (tra l'altro deprecato) di quel thread.
Rimane quindi il solito problema della connessione aperta.

Dai un'occhiata allo pseudo codice che ho postato all'inizio, c'e' una soluzione al problema sulla quale puoi lavorare.

[fbcyborg]

dunque... questa è la mia classe Boss

public class FTPServerMultiThread extends Thread{
	
	private ServerSocket mainSocket = null;
	
	public FTPServerMultiThread(){
		
	}
	
	public void run(){

		int serverPort = 21; // FTP server port
		Socket connectionSocket;
		String[][] userList = null;
		String slash = System.getProperty("file.separator");
		String root = System.getProperty("user.dir") + slash +"FileSystem";
		
		
		try{
			mainSocket = new ServerSocket(serverPort);
				
			System.out.println("Server in ascolto sulla porta "+ serverPort +"...");
			
			while(true){
				connectionSocket = mainSocket.accept();
				if (connectionSocket.isConnected()){
					new ClientHandler(connectionSocket).start();
				}
				else Thread.yield();
			}
		}catch (IOException ex){}
	}
	
	/*public void offline() throws IOException{
		mainSocket.close();
	}*/
}

ho provato a mettere quell'if nel while, ma non capisco che c'entra con il fatto di chiudere il server se ci sono o meno client connessi....
Se io volessi chiudere il server brutalmente, i client verrebbero disconnessi dando un errore all'utente..

[fek]

Guarda:

while (!QuitServer())
  {  
    if (IsConnectionAvailable())
    {
       thread = CreateThread();
       thread.HandleConnection();    
    }
    
    ReleaseCPUToAnotherThread();
  }

  WaitForAllConnectionsToFinish();

Che differenza c'e' fra questo loop e il tuo loop while(true)?

[fbcyborg]

il fatto del quitServer().
questo significa che devo implementare un nuovo metodo? analogo a offline() ?

alla fine siamo sempre lì.. a me servirebbe tipo un SEGNALE che inviato a quel thread, termini...
dici così?

public class FTPServerMultiThread extends Thread{
	
	private ServerSocket mainSocket = null;
	private boolean status = false;
	
	public FTPServerMultiThread(){
		
	}
	
	public void run(){

		int serverPort = 21; // FTP server port
		Socket connectionSocket;
		String[][] userList = null;
		String slash = System.getProperty("file.separator");
		String root = System.getProperty("user.dir") + slash +"FileSystem";
		
		
		try{
			mainSocket = new ServerSocket(serverPort);
			status = true;	
			System.out.println("Server in ascolto sulla porta "+ serverPort +"...");
			
			while(status){
				connectionSocket = mainSocket.accept();
				if (connectionSocket.isConnected()){
					new ClientHandler(connectionSocket).start();
				}
			}
			mainSocket.close();
		}catch (IOException ex){}
	}
	
	public void offline() throws IOException{
		status = false;
	}
}

e poi come faccio a invocare quel metodo offline() di quell'esatto thread?