Newsgroup: it.comp.java
Titolo: controllo esecuzione dopo thread

in un ciclo while ho inserito l'avvio di un thread.all'interno del 
thread vengono eseguite determinate operazioni.vorrei che si andasse 
avanti con le istruzioni, e quindi si passasse anche da un ciclo a 
quello successivo solo al termine delle operazioni all'interno del 
thread.così da non permettere che si accavallino le esecuzioni.come 
posso fare?grazie


Posto un esempio di come farei io. Nel metodo main ho messo quello che 
dovrebbe essere il tu ciclo. In pratica nell'oggetto thread ho messo un 
flag che dice se l'elaborazione è terminata.
L'accesso al flag è synchronized.
Al termine di ogni ciclo ci si mette in attesa che il thread imposti il 
flag ended a true.
---------------------------------------------------------------------
public class MioThread extends Thread{
   private boolean ended = false;
   public boolean isEnded() {
     return ended;
   }
   public void run() {
     //...
     synchronized (this) {
       ended = true;
       this.notifyAll();
     }
   }
   public static void main(String[] args) throws InterruptedException {
     while(true) {
       //...
       MioThread thr = new MioThread();
       thr.start();
       //...
       synchronized (thr) {
         while(!thr.ended)
           thr.wait();
       }
     }
   }
}
---------------------------------------------------------------------
Andre Polci

grazie mille della risposta esauriente ma volevo aggiungere una cosa.per 
ogni ciclo io ho diversi thread avviati.vorrei aspettare che finiscano 
tutti prima di fare un altro ciclo.nella tua soluzione si parla solo di 
un thread.come si può fare x gestirne di +?grazie mille ancora

iblinku wrote:

Allora la questione si fa un pò più complicata, ma non molto.
L'idea è di contare quanti thread sono in esecuzione e aspettare che 
siano terminati.
-----------------------------------------------------------------------------
class Counter {
   int count = 0;
   public synchronized void increment() {count++;}
   public synchronized void decrement() {
     count--;
     this.notifyAll();
   }
   public synchronized void waitZero() throws InterruptedException {
     while(count>0) {
       this.wait();
     }
   }
}
public class MioThread extends Thread{
   private final Counter counter;
   public MioThread(Counter counter) {
     this.counter = counter;
     counter.increment();
   }
   public void run() {
     // do something
     counter.decrement();
   }
   public static void main(String[] args) throws InterruptedException {
     Counter counter = new Counter();
     while(true) {
       //...
       MioThread thr = new MioThread(counter);
       thr.start();
       // do something
       MioThread thr2 = new MioThread(counter);
       thr2.start();
       // do something else
       counter.waitZero();
     }
   }
}
-----------------------------------------------------------------------------
A questo punto, se mi ricordassi qualcosina in più dai miei studi 
universitari, potrei forse dire che counter rappresenta una tecnica ben 
nota (oggi si direbbe un pattern, ma questa materia si è sviluppata ben 
prima che fossero inventati questi), anche se utilizzata in un modo un 
pò insolito.
Purtroppo i miei ricordi sono un pò annebbiati (se lo sa il mio 
professore mi ritira la laurea) e ho paura di dire castronerie, quindi 
se c'e' qualcuno più ferrato di me si faccia avanti.
Andrea