Newsgroup: it.comp.java
Titolo: sospendere un thread?

supponete di avere du thread ad un "capo" di un socket, uno si dedica a
prendere messaggi dal socket, l'altro compie delle elaborazioni in base
ai messaggi che arrivano dal socket. Dal socket puo' arrivare un comando
di sospensione, ma ho letto che chi usa suspend() e resume() non e'
degno di programmare (anche se nel mio caso non dovrei risciare delle
deadlock).
Mi sono rivolto alla wait()/notify() che pero' fermano l'esecuzione
anche del thread che ascolta il socket, rendendo cosi' impossibile
l'ascolto del messaggio di resume...
qualche idea.
Ciao
-- 
Massimiliano Cialdi
cia...@firenze.net
cia...@control.dsi.unifi.it
cia...@geoide.it

l'ascolto del messaggio di resume...
Sicuramente wait() e notify() sono la strada giusta, anche perche' gli
altri sono deprecated (da quale versione ora non ricordo), comunque
potresti fare una cosa del tipo :
Il thread principale ascolta la socket, e va ad impostare l'operazione
che andra' a compiere l'altro thread, se questa impostazione avviene
all'interno di un oggetto, potresti fare in modo che il metodo in
questione sia synchronized, in questo modo il thread principale entra
in maniera mutamente esclusiva all'interno del metodo, imposta
l'operazione che il thread secondario dovra' compiere, dopo di che fa
una bella notify() (se non c'e' nessuno in wait() poco male). Il
thread secondario, ad ogni passo, legge l'operazione da eseguire, la
esegue, finito si mette in wait (se si deve fermare, e' una mia
supposizione!), quando arriva il thread principale, lo sveglia, legge
l'operazione, se e' di sospensione si rimette in wait() altrimenti la
esegue. Ex
...
private static final int NO_OP = 0;
private static final int WAIT = 1;
...
private int operazione;
...
public synchronized void impostaOperazione(int op)
{	operazione = op;
	this.notify();
}
// anche private dipende
public void leggiOperazione()
{    synchronized(this)
     {    if ((operazione == WAIT) || (operazione == NO_OP))
          {    do
               {    try
                    {    this.wait():
                    }
                    catch(InterruptedException e)
                    {    e.printStackTrace();
                    }
               }while(operazione ==  WAIT);
          }
     }
     // switch per le altre operazioni, o una soluzione 
     // piu' elegante. Prima di chiamare l'operazione, 
     // imposta (operazione = NO_OP;) altrimenti vai in
     // deadlock	
}
Spero che funzioni, ciao 
			Gabriele "SunGray" Lana
 

 l'operazione, se e' di sospensione si rimette in wait() altrimenti la
Il guaio e' che non ho un problema di produttore/consumatore. Ho una
specie di video registratore con i comandi di play e pause che arrivano
dal socket, lui mostra i fotogramma a intervalli predefiniti, e lo deve
fare indefinitamente, a meno che non arrivi il comando di pause al che
si deve fermare, e quando deve riprendere lo deve fare esattamente da
dove era, cioe' se era stato interrotto a meta' del suo intervallo di
attesa quando riprende deve attendere l'altra meta'.
ciao


attesa quando riprende deve attendere l'altra meta'.
Proviamo a modificare un po' le cose
...
private static final int NUM_MILLIS = <quelli che vuoi>;
private static final int NO_OP = 0;
private static final int WAIT = 1;
...
private int operazione;
...
public synchronized void impostaOperazione(int op)
{    if (operazione == WAIT)
          this.notify();
     operazione = op;    
}
// anche private dipende
public void leggiOperazione()
{    int numMillisecondiPassati = 0;
 
     while(true)
     {
     synchronized(this)
     {    do
          {   if (operazione == WAIT)  
              {    try
                   {    this.wait():
                   }
                   catch(InterruptedException e)
                   {    e.printStackTrace();
                   }
                   operazione = NO_OP;
              }
              else
              {    // Non c'e' wait
                   this.wait(<numero di millisecondi>);  
                   numMillisecondiPassati += <numero di millisecondi>;
               }
          }while(numMillisecondiPassati < NUM_MILLIS);
     }
     // switch per le altre operazioni, o una soluzione 
     // piu' elegante. 
     numMillisecondiPassati = 0;
     }
}
Se metti <numero di millisecondi> in modo che NUM_MILLIS ne sia
multiplo e' meglio, mi rendo conto che non e' molto elegante, ma
potrebbe andare bene?