Newsgroup: it.comp.java
Titolo: morte di un thread

Come si chiama l'ultimo metodo che viene richiamato prima che un thread
muoia? E' possibile ridefinirlo facendo ad esempio in modo che, prima di
morire, il thread incrementi un contatore?
Grazie ciao!!!


Crea una nuova classe che implementi Runnable. Ora è sufficiente mettere 
un'istruzione alla fine del metodo run() in modo che il contatore venga 
decrementato (magari all'interno di una clausola finally).
Gaetano

 Crea una nuova classe che implementi Runnable. Ora č sufficiente mettere


 thread che è in un ciclo while(true) infinito bisogna usare il metodo stop?
No, Thread.stop() è deprecato. Si deve utilizzare interrupt().
Puoi ad esempio utilizzare una variabile di controllo per segnalare la 
condizione di terminazione:
private boolean terminazione = false;
private Thread thread = new Thread();
private boolean synchronized devoContinuare() { return !terminazione; }
public void synchronized stopPlease()
{
   terminazione = true;
   thread.interrupt();
}
quindi nel ciclo run() si farà:
while (devoContinuare())
{
   try { ... }
   catch (InterruptedException e) { }
}
e chi vuole interrompere il thread fara:
runnable.stopPlease();
Gaetano

 condizione di terminazione:
O semplicemente :
while (!interrupted()) {
        //quello che devi fare
}
e chi vuole interrompere il thread fa thread.interrupt(). 
In generale è il Thread che deve controllare se qualcuno gli ha chiesto di 
terminare. Poi questo controllo lo metti dove ti pare, se vuoi anche nel 
ciclo tipo:
if(interrupted()) break;
Ciao
Matteo



Non esiste un ultimo metodo predefinito come vuoi tu.
Puoi pero' fare una cosa del genere:
    class MyThread extends Thread {
        public MyThread(Runnable r) {
            super(r);
        }
        public void run() {
          try {
            register();
            super.run();
          } finally {
            deregister();
          }
        }
        void register() {... before the thread's work starts ...}
        void deregister() {... after the thread is done ...}
    }
E istanzi i tuoi threads nel seguente modo:
    MyRunnable myRunnable = new MyRunnable(...constructor parameters...);
    Thread t = new MyThread(myRunnable);
    t.start();
dove MyRunnable e' una tua classe che implementa Runnable
e che quindi ha un metodo public run.
Ad esempio:
  class MyRunnable implements Runnable {
    MyRunnable(...constructor parameters...) {
        ...constructor...
    }
    public void run {
        ...algorithm...
    }
  }
Ovviamente i tuoi contatori possono essere gestiti
dentro register e deregister di MyThread.
- Dario

 e chi vuole interrompere il thread fa thread.interrupt().
interrupted() come funziona ?
Se nel while metto un try catch(InterruptedException) , interrupted non
funziona piu'... quindi, in pratica , interrupted() e' un
try catch(InterruptedException) {return true} ?

 try catch(InterruptedException) {return true} ?
Temo di non aver capito la domanda.
Una InterruptedException viene lanciata solo se il Thread è bloccato in una 
chiamata tipo sleep.
Dove lo vuoi mettere il try catch?
Allora, niente messaggi asincroni (tipo segnali Unix).
Ogni Thread dovrebbe ogni tanto controllare se qualcuno vuole che termini. 
Se un Thread vuole che un altro termini fa interrupt() che setta a vero una 
variabile. 
interrupted testa la variabile e se era vera restituisce vero ma la imposta 
a falso.
Cioè se su un thread è stato chiamato interrupt:
interrupted() //restituisce true;
interrupted() //restituisce false;
isInterrupted invece non è statico e lascia la variabile com'era quindi 
nell'esempio di prima restituirebbe sempre true.
Qual'è il problema? Se il Thread è bloccato in una sleep() (o simili) non 
puo' testare la variabile e quindi viene "svegliato", cioè sbloccato da una 
InterruptedException.
A questo punto non ho ancora capito dove dicevi di mettere il try catch ;)
Ciao
Matteo

> A questo punto non ho ancora capito dove dicevi di mettere il try catch ;)
Ottima la spiegazione. Ora pero' provo a spiegarti meglio.
while(!interrupted()) {
    try {
        sleep (5000)
    }
    catch(InterruptedException) {
        System.io.println("Aio'... ");
    }
}
Se invoco interrupt() su questo codice, viene "risvegliato" il thread che
esce dallo stato di sleep, ma il ciclo while non si interrompe.
A questo punto come potrei fare per far terminare il ciclo ?
Io ho usato una variabile booleana e dentro al catch c'e' un STOP=true e il
while e' un
while(!interrupted()&&!STOP) {
pero' non ho provato a propagare l'eccezione da dentro al catch, magari con
un throw...
Spero di essere stato piu' chiaro :D
Saluti
Luca

 esce dallo stato di sleep, ma il ciclo while non si interrompe.
Metti un break dopo la println e vedrai che esce dal loop!
 while(!interrupted()) {
   try {
    sleep (5000)
   }
   catch(InterruptedException) {
     System.io.println("Aio'... ");
      break;
   }
 }
- Dario

 Io ho usato una variabile booleana e dentro al catch c'e' un STOP=true 
Se non ti piacciono i cicli poco strutturati (come quello che ha suggerito 
Dario facendo uso del break) puoi comunque utilizzare la variabile boolean 
che gia' controlla il Thread.
Cioč nel catch metti Thread.currentThread().interrupt() ed esce dal ciclo.
Ciao
Matteo

 A questo punto come potrei fare per far terminare il ciclo ?
riscrivi il tuo codice
try
{
    while(!interrupted())
    {
           sleep (5000);
    }
}
catch(InterruptedException e)
{
        System.io.println("Aio'... ");
}
ciao_O
Andrea
http://jame.sf.net

 }
Questa mi piace :D
Tnks !!
Luca