Wie warten, bis mehrere Threads abgeschlossen sind?

Question

Was ist ein Weg, einfach zu warten, bis alle Gewindeprozesse beendet sind? Zum Beispiel, sagen wir mal, ich habe:

public class DoSomethingInAThread implements Runnable{ 

    public static void main(String[] args) { 
     for (int n=0; n<1000; n++) { 
      Thread t = new Thread(new DoSomethingInAThread()); 
      t.start(); 
     } 
     // wait for all threads' run() methods to complete before continuing 
    } 

    public void run() { 
     // do something here 
    } 


} 

Wie verändern ich das so die main() Methode Pausen an der Kommentar, bis alle run() Methoden Ausfahrt Fäden? Vielen Dank!

Answer 1

Sie stellen alle Themen in einem Array, beginnen sie alle, und haben dann eine Schleife

for(i = 0; i < threads.length; i++) 
    threads[i].join(); 

Jeder beitreten werden blockiert, bis der jeweilige Thread beendet hat. Threads können in einer anderen Reihenfolge abgeschlossen werden als Sie ihnen beitreten, aber das ist kein Problem: Wenn die Schleife beendet wird, sind alle Threads abgeschlossen.

Answer 2

Sie können es mit dem Objekt "ThreadGroup" and its parameter activeCount:

Answer 3

Wenn Sie eine Liste der Themen zu machen, können Sie eine Schleife durch sie und .join() gegen jeden, und der Schleife wird beendet, wenn alle Fäden haben. Ich habe es nicht versucht.

http://docs.oracle.com/javase/8/docs/api/java/lang/Thread.html#join()

Answer 4

Eine Möglichkeit wäre, einen List von Thread s zu erstellen, jeden Thread zu erstellen und zu starten und ihn der Liste hinzuzufügen. Sobald alles gestartet ist, durchlaufen Sie die Liste und rufen Sie join() auf jedem. Es spielt keine Rolle, in welcher Reihenfolge die Threads ausgeführt werden. Alles, was Sie wissen müssen, ist, dass zu dem Zeitpunkt, zu dem die zweite Schleife beendet ist, jeder Thread abgeschlossen sein wird.

Ein besserer Ansatz ist es, eine ExecutorService und die damit verbundene Methoden zu verwenden:

List<Callable> callables = ... // assemble list of Callables here 
           // Like Runnable but can return a value 
ExecutorService execSvc = Executors.newCachedThreadPool(); 
List<Future<?>> results = execSvc.invokeAll(callables); 
// Note: You may not care about the return values, in which case don't 
//  bother saving them 

eine ExecutorService Verwendung (und all die neuen Sachen von Java 5 ist concurrency utilities) unglaublich flexibel ist, und das obige Beispiel kaum noch Kratzer die Oberfläche.

Answer 5

Vermeiden Sie die Thread-Klasse insgesamt und stattdessen die höheren Abstraktionen in java.util.concurrent vorgesehen verwenden

Die ExecutorService Klasse stellt die method invokeAll, die genau das zu tun scheint, was Sie wollen.

Answer 6

Dies wäre ein Kommentar, aber ich kann noch keine Kommentare machen.

MartinK, ich bin gespannt, wie Sie ThreadGroup verwenden würde. Hast du das schon mal gemacht?

Ich sehe, dass oben, Sie schlage vor, Check activeCount - abgesehen von MartinvLöwis ‚s Besorgnis über Polling für den Moment beiseite, ich habe ein anderes Anliegen mit activeCount selbst.

Caveat: Ich habe mit nicht versucht, so dass ich bin kein Experte in der Sache, sondern nach den javadocs, es gibt eine Schätzung der Anzahl der aktiven Threads.

Persönlich würde ich es verabscheuen zu versuchen, ein System auf einer Schätzung zu bauen. Hast du noch einen Gedanken darüber, wie es geht, oder missversteh ich das Javadoc?

Answer 7

Je nach Ihren Bedürfnissen sollten Sie auch die Klassen CountDownLatch und CyclicBarrier im java.util.concurrent-Paket überprüfen. Sie können nützlich sein, wenn Sie möchten, dass Ihre Threads aufeinander warten, oder wenn Sie eine feinere Kontrolle darüber haben wollen, wie Ihre Threads ausgeführt werden (z. B. in ihrer internen Ausführung darauf warten, dass ein anderer Thread einen Status setzt). Sie können auch eine CountDownLatch-Funktion verwenden, um allen Threads zu signalisieren, dass sie gleichzeitig starten sollen, anstatt sie nacheinander zu starten, wenn Sie die Schleife durchlaufen. Die Standard-API-Dokumentation enthält ein Beispiel dafür sowie eine weitere CountDownLatch, um darauf zu warten, dass alle Threads ihre Ausführung abschließen.

Answer 8

import java.util.ArrayList; 
import java.util.List; 
import java.util.concurrent.ExecutionException; 
import java.util.concurrent.ExecutorService; 
import java.util.concurrent.Executors; 
import java.util.concurrent.Future; 

public class DoSomethingInAThread implements Runnable 
{ 
    public static void main(String[] args) throws ExecutionException, InterruptedException 
    { 
     //limit the number of actual threads 
     int poolSize = 10; 
     ExecutorService service = Executors.newFixedThreadPool(poolSize); 
     List<Future<Runnable>> futures = new ArrayList<Future<Runnable>>(); 

     for (int n = 0; n < 1000; n++) 
     { 
     Future f = service.submit(new DoSomethingInAThread()); 
     futures.add(f); 
     } 

     // wait for all tasks to complete before continuing 
     for (Future<Runnable> f : futures) 
     { 
     f.get(); 
     } 

     //shut down the executor service so that this thread can exit 
     service.shutdownNow(); 
    } 

    public void run() 
    { 
     // do something here 
    } 
} 

Answer 9

Erstellen Sie das Thread-Objekt innerhalb der ersten for-Schleife.

for (int i = 0; i < threads.length; i++) { 
    threads[i] = new Thread(new Runnable() { 
     public void run() { 
      // some code to run in parallel 
     } 
    }); 
    threads[i].start(); 
} 

Und dann so was jeder hier sagt.

for(i = 0; i < threads.length; i++) 
    threads[i].join(); 

Answer 10

Verwenden Sie java.util.concurrent.CountDownLatch. Beispiele in javadocs

Answer 11

Wie Martin K vorgeschlagen java.util.concurrent.CountDownLatch scheint eine bessere Lösung dafür zu sein. Nur das Hinzufügen ein Beispiel für die gleiche

 public class CountDownLatchDemo 
{ 

    public static void main (String[] args) 
    { 
     int noOfThreads = 5; 
     // Declare the count down latch based on the number of threads you need 
     // to wait on 
     final CountDownLatch executionCompleted = new CountDownLatch(noOfThreads); 
     for (int i = 0; i < noOfThreads; i++) 
     { 
      new Thread() 
      { 

       @Override 
       public void run() 
       { 

        System.out.println("I am executed by :" + Thread.currentThread().getName()); 
        try 
        { 
         // Dummy sleep 
         Thread.sleep(3000); 
         // One thread has completed its job 
         executionCompleted.countDown(); 
        } 
        catch (InterruptedException e) 
        { 
         // TODO Auto-generated catch block 
         e.printStackTrace(); 
        } 
       } 

      }.start(); 
     } 

     try 
     { 
      // Wait till the count down latch opens.In the given case till five 
      // times countDown method is invoked 
      executionCompleted.await(); 
      System.out.println("All over"); 
     } 
     catch (InterruptedException e) 
     { 
      e.printStackTrace(); 
     } 
    } 

} 

Answer 12

statt join(), die eine alte API ist, können Sie CountDownLatch verwenden. Ich habe Ihren Code wie folgt geändert, um Ihre Anforderung zu erfüllen.

import java.util.concurrent.*; 
class DoSomethingInAThread implements Runnable{ 
    CountDownLatch latch; 
    public DoSomethingInAThread(CountDownLatch latch){ 
     this.latch = latch; 
    } 
    public void run() { 
     try{ 
      System.out.println("Do some thing"); 
      latch.countDown(); 
     }catch(Exception err){ 
      err.printStackTrace(); 
     } 
    } 
} 

public class CountDownLatchDemo { 
    public static void main(String[] args) { 
     try{ 
      CountDownLatch latch = new CountDownLatch(1000); 
      for (int n=0; n<1000; n++) { 
       Thread t = new Thread(new DoSomethingInAThread(latch)); 
       t.start(); 
      } 
      latch.await(); 
      System.out.println("In Main thread after completion of 1000 threads"); 
     }catch(Exception err){ 
      err.printStackTrace(); 
     } 
    } 
} 

Erklärung:

1. CountDownLatch wurde mit gegebenen Zählung 1000 als pro Ihre Anforderung initialisiert.

2. Jeder Worker-Thread DoSomethingInAThread dekrementiert den CountDownLatch, der im Konstruktor übergeben wurde.

3. Hauptthread CountDownLatchDemoawait() bis die Zählung Null geworden ist. Sobald die Zählung zu Null geworden ist, werden Sie in der Ausgabe unterhalb der Linie ankommen.

   In Main thread after completion of 1000 threads 
   

Weitere Daten aus der Oracle-Dokumentation Seite

public void await() 
      throws InterruptedException 

Ursachen der aktuelle Thread warten, bis die Verriegelung bis auf Null gezählt hat, es sei denn, der Faden unterbrochen wird.

Siehe verwandte SE Frage für weitere Optionen:

wait until all threads finish their work in java

Answer 13

Als Alternative zu CountDownLatch Sie auch CyclicBarrier zum Beispiel verwenden können

public class ThreadWaitEx { 
    static CyclicBarrier barrier = new CyclicBarrier(100, new Runnable(){ 
     public void run(){ 
      System.out.println("clean up job after all tasks are done."); 
     } 
    }); 
    public static void main(String[] args) { 
     for (int i = 0; i < 100; i++) { 
      Thread t = new Thread(new MyCallable(barrier)); 
      t.start(); 
     }  
    } 

}  

class MyCallable implements Runnable{ 
    private CyclicBarrier b = null; 
    public MyCallable(CyclicBarrier b){ 
     this.b = b; 
    } 
    @Override 
    public void run(){ 
     try { 
      //do something 
      System.out.println(Thread.currentThread().getName()+" is waiting for barrier after completing his job."); 
      b.await(); 
     } catch (InterruptedException e) { 
      e.printStackTrace(); 
     } catch (BrokenBarrierException e) { 
      e.printStackTrace(); 
     } 
    }  
} 

Um CyclicBarrier in diesem Fall barrier.await() zu verwenden, sollte die letzte Anweisung das heißt, wenn der Thread mit seiner Arbeit erledigt ist. CyclicBarrier kann mit seiner reset() - Methode erneut verwendet werden. Um javadocs zu zitieren:

Eine CyclicBarrier unterstützt einen optionalen Runnable-Befehl, der einmal pro Sperrpunkt ausgeführt wird, nachdem der letzte Thread in der Gruppe eingetroffen ist, aber bevor Threads freigegeben werden. Diese Barrier-Aktion ist nützlich, um den Shared-State zu aktualisieren, bevor eine der Parteien fortfährt.