Come attendere il completamento di un thread prima dell'avvio di un altro thread in Java/Android?

Question

Diciamo che ho questo codice molto semplice:

for(int i = 0; i < 10; i++) { 
    thread = new Thread(this); 
    thread.start(); 
} 

Tuttavia, in questo codice, il filo inizia a quanto pare 10 volte in una sola volta e non aspetta prima che il precedente è terminato. Come controllate se il thread è finito prima di far ripartire il thread?

Answer 1

Prima di rispondere alla tua domanda, ti consiglio vivamente di esaminare ExecutorServices come ad esempio lo ThreadPoolExecutor.

Ora per rispondere alla tua domanda:

Se si desidera attendere per il thread precedente per finire, prima di iniziare il prossimo, si aggiunge thread.join() tra:

for(int i = 0; i < 10; i++) { 
    thread = new Thread(this); 
    thread.start(); 

    thread.join(); // Wait for it to finish. 
} 

---

Se vuoi dare il via a 10 discussioni, lasciare che facciano il loro lavoro, e poi continuare, tu join su di loro dopo il ciclo:

Thread[] threads = new Thread[10]; 
for(int i = 0; i < threads.length; i++) { 
    threads[i] = new Thread(this); 
    threads[i].start(); 
} 

// Wait for all of the threads to finish. 
for (Thread thread : threads) 
    thread.join(); 

Answer 2

Se ogni thread deve attendere che la precedente per finire prima di iniziare, è meglio avere un filo unico di eseguire il metodo run originale 10 volte in sequenza:

Runnable r = new Runnable() { 
    public void run() { 
     for (int i = 0; i < 10; i++) { 
      OuterClass.this.run(); 
     } 
    } 
} 
new Thread(r).start(); 

Answer 3

Proprio per elaborare su suggerimento di aioobe:

Prima di rispondere alla tua domanda, vi incoraggio vivamente di guardare in ExecutorServices come ad esempio la ThreadPoolExecutor.

C'è un particolare ExecutorService che può essere utilizzato per questo compito:

ExecutorService pool = Executors.newSingleThreadExecutor(); 
for (int i=0; i<10; i++) { 
    pool.submit(this); //assuming this is a Runnable 
} 
pool.shutdown(); //no more tasks can be submitted, running tasks are not interrupted 

newSingleThreadExecutor() è simile a chiamare newFixedThreadPool(1) ma assicura che il servizio non può essere riconfigurato per utilizzare più di un thread.