[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]

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/2002/09/04/nio.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]

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 :confused: :confused: :confused: :confused:
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:

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/2002/09/04/nio.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.... :muro: :muro:

[fek]

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.... :muro: :muro:

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... :confused:
sarà il caldo, la voglia di mare, ma non saprei proprio... :D
.. 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]

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... :confused:
sarà il caldo, la voglia di mare, ma non saprei proprio... :D
.. 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]

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?

[fek]

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


A occhio si'


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

Da qualche parte nel thread principale devi creare un oggetto Server per lanciare il thread, giusto?

Qualcosa tipo:

FTPServerMultiThread server = new FTPServerMultiThread(..);

A questo punto dal thread principale o dalla gui scrivi qualcosa del tipo:

server.goOffline();
server.waitForCompletion();

Il primo messaggio chiede al server di chiudersi, il secondo messaggio aspettera' che il server completi tutte le connessioni, faccia un altro giro del loop, testi il flag che goOffline() ha impostato e segnali la sua chiusura.

Per concludere, fai un po' di refactoring per far assomigliare il codice di run() a quello che ho scritto io per migliorare la leggibilita'.

[fbcyborg]

ok... ora sembra che ho risolto il problema...
ecco la mia classe Boss:

public class FTPServerMultiThread extends Thread{

private ServerSocket mainSocket = null;
private boolean online = false;
private Socket connectionSocket;

public void run(){

int serverPort = 21; // FTP server port
String slash = System.getProperty("file.separator");
String root = System.getProperty("user.dir") + slash +"FileSystem";

try{
mainSocket = new ServerSocket(serverPort);
online = true;
System.out.println("Server in ascolto sulla porta "+ serverPort +"...");

while(status()){
connectionSocket = mainSocket.accept();
new ClientHandler(connectionSocket).start();
}
mainSocket.close();
}catch (IOException ex){}
}

public boolean status() throws IOException{
return online;
}

public void goOffline() throws IOException{
mainSocket.close();
connectionSocket.close();
online = false;
try{
this.join();
// termino il thread corrente, non so se è giusto
}catch (InterruptedException ie){}
}
}


mentre invece dalla gui faccio:

private FTPServerMultiThread conn = null; // come variabile GLOBALE

// nel codice del bottone per andare online:
conn = new FTPServerMultiThread();
conn.start();

// per il bottone offline invece:
try{
conn.goOffline();
}catch(IOException ex){}


giusto????
adesso pare funzionare!!!! anche se ho fatto un bel po' di fatica a capire bene.... beh.. magari me lo ricordo meglio...

[fek]

giusto????
adesso pare funzionare!!!! anche se ho fatto un bel po' di fatica a capire bene.... beh.. magari me lo ricordo meglio...

Se funziona e fa quello che ti serve e' giusto :)

[fbcyborg]

Ok, ti ringrazio per tutto, e soprattutto per avermi guidato a questa soluzione...
mi chidevo se fosse giusto nel senso che a volte "non basta che funzioni".. Posso anche aver scritto cavolate, e funzionare. Magari poi il prof mi dice che la scelta fatta non va bene.. Insomma all'uni ci fanno (comprensibilmente) una testa tanto grossa perchè un sw oltre che funzionare dev'essere efficiente e ben strutturato. e spesso non è sufficiente il "basta che funzioni". ecco perchè...
Cmq l'unica cosa è che quando chiudo il socket del server, mi da un'eccezione in un metodo readline(), poichè il socket è stato chiuso. Quindi avviene una SocketException. Questo non blocca il programma server, e il client rileva una chiusura della connessione. Però è un po' rompiballe il fatto che in console appaiano i messaggi di errore...

[fek]

Ok, ti ringrazio per tutto, e soprattutto per avermi guidato a questa soluzione...
mi chidevo se fosse giusto nel senso che a volte "non basta che funzioni".. Posso anche aver scritto cavolate, e funzionare. Magari poi il prof mi dice che la scelta fatta non va bene.. Insomma all'uni ci fanno (comprensibilmente) una testa tanto grossa perchè un sw oltre che funzionare dev'essere efficiente e ben strutturato. e spesso non è sufficiente il "basta che funzioni". ecco perchè...


Sul "ben strutturato" hanno pienamente ragione, infatti ti ho consigliato di riorganizzare il codice per farlo "assomigliare" di piu' al codice che ti ho postato.
Te lo riposto:


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

ReleaseCPUToAnotherThread();
}

WaitForAllConnectionsToFinish();


Nota come metto una chiamata ad un metodo invece di un certo numero di righe di codice che eseguono effettivamente quella funzione. In questa versione il codice si legge "quasi come" fosse inglese. Senza esagerare troppo, dovresti tendere sempre a rendere il tuo codice leggibile come fosse un testo e non debba essere "decifrato".

Se il codice e' sempre strutturato cosi', vedrai che e' piu' facile non solo da riorganizzare o modificare in caso cambiassero le esigenze, ma anche da debuggare in caso non facesse esattamente quello che ti serve. Il tuo codice dovrebbe, teoricamente, non aver mai bisogno di essere commentato, perche' si commenta da solo.

Non e' difficile passare dal tuo codice a questa forma, basta applicare ripetutamente il refactoring chiamato Extract Method (http://www.refactoring.com/catalog/extractMethod.html).

Riguardo all'efficienza invece il discorso e' un po' diverso. L'efficienza non e' una caratteristica del codice (la qualita' lo e'), ma e' un requisito che il codice deve soddisfare.

Se non c'e' un requisito di efficienza esplicito, tu devi sempre e comunque privilegiare la leggibilita' e la qualita' del codice alla sua efficienza, qualora ti si presentasse una scelta da fare. E' ovvio che non devi rendere il codice piu' inefficiente di proposito. Infine, sempre riguardo al discorso sull'efficienza, se devi scegliere di rendere del codice meno leggibile ma piu' efficiente, devi sempre farlo avendo dati precisi sulla sua velocita' di esecuzione (o occupazione di memoria) e dimostrare che il cambiamento ha effettivamente apportato benefici misurabili e i requisiti di efficienza sono stati raggiunti o almeno avvicinati.

Infine, ricordati che:

"Every fool can write code that a machine can understand, only good programmers can write code that a human can understand".

E proprio ultimamente anche in questo forum questa piccola considerazione si e' rivelata estremamente vera e attuale.


Cmq l'unica cosa è che quando chiudo il socket del server, mi da un'eccezione in un metodo readline(), poichè il socket è stato chiuso. Quindi avviene una SocketException. Questo non blocca il programma server, e il client rileva una chiusura della connessione. Però è un po' rompiballe il fatto che in console appaiano i messaggi di errore...

Questo e' un "sintomo". Se non sai perche' quella eccezione viene generata e non sai come evitarla, vuol dire che non comprendi esattamente quello che hai scritto e le sue implicazioni. Cerca di semplificare ulteriormente il codice se e' possibile, oppure rifattorizzarlo di modo da eliminare questo comportamento anomalo. Non ignorare questi segnali quando programmi, e' un debito che prima o poi dovrai pagare, quindi meglio toglierselo di torno subito.

[fbcyborg]

ok ti ringrazio... vedrò cosa riescirò a fare...
ora sto provando da linux! problemi su problemi.. ma non importa! :D

[fek]

ok ti ringrazio... vedrò cosa riescirò a fare...
ora sto provando da linux! problemi su problemi.. ma non importa! :D

I programmatori sono pagati per risolvere problemi :D

[maxithron]

I programmatori sono pagati per risolvere problemi :D

sei sicuro? :D

in certi casi, per esperienza personale di programmatori che ho conosciuto.....diciamo che erano pagati per crearne di nuovi :D

[fek]

sei sicuro? :D

in certi casi, per esperienza personale di programmatori che ho conosciuto.....diciamo che erano pagati per crearne di nuovi :D

In teoria si' :D