Thread.join() entspricht in Executor

Question

Ich habe eine neue Frage. Ich habe diesen Code:

public class Main 
{ 

    public static void main(String[] args) throws InterruptedException 
    { 
     // TODO Auto-generated method stub 
     IntHolder aHolder=new IntHolder(); 
     aHolder.Number=0; 

     IncrementorThread A= new IncrementorThread(1, aHolder); 
     IncrementorThread B= new IncrementorThread(2, aHolder); 
     IncrementorThread C= new IncrementorThread(3, aHolder); 

     A.start(); 
     B.start(); 
     C.start(); 

     A.join(); 
     B.join(); 
     C.join(); 
     System.out.println("All threads completed..."); 

    } 

} 

Welche für alle Threads abgeschlossen warten. Wenn ich Executors wie folgt aus:

public class Main 
{ 

    public static void main(String[] args) 
    { 
     // TODO Auto-generated method stub 
     IntHolder aHolder=new IntHolder(); 
     aHolder.number=0; 

     IncrementalRunable A= new IncrementalRunable(1, aHolder); 
     IncrementalRunable B= new IncrementalRunable(2, aHolder); 
     IncrementalRunable C= new IncrementalRunable(3, aHolder); 

     ExecutorService exec = Executors.newFixedThreadPool(3); 
     exec.execute(A); 
     exec.execute(B); 
     exec.execute(C); 
     //Don't know what to do here 

     System.out.println("All threads completed..."); 
    } 
} 

Wie kann ich den Hauptthread suspendieren für alle Fäden in der Testamentsvollstrecker zu warten, um zu beenden, dh die „Alle Threads abgeschlossen ...“ sollte nach dem alle gedruckt werden Threads haben ihre Arbeit gemacht?

Answer 1

executor.shutdown(); 
while (!executor.awaitTermination(24L, TimeUnit.HOURS)) { 
    System.out.println("Not yet. Still waiting for termination"); 
} 

Verwendung shutdown() + awaitTermination() Kombination.

EDIT:

Basierend auf dem Kommentar von @Lital

List<Callable<Object>> calls = new ArrayList<Callable<Object>>(); 
calls.add(Executors.callable(new IncrementalRunable(1, aHolder))); 
calls.add(Executors.callable(new IncrementalRunable(2, aHolder))); 
calls.add(Executors.callable(new IncrementalRunable(3, aHolder))); 

List<Future<Object>> futures = executor.invokeAll(calls); 

HINWEIS: invokeAll() wird nicht zurückkehren, bis alle Aufgaben abgeschlossen sind (entweder durch Fehler oder Abschluss erfolgreiche Ausführung) .

Answer 2

exec.shutdown(); 
    // Wait until all threads are finish 
    exec.awaitTermination(); 

Answer 3

Sie sollten den Executor nicht wie folgt verwenden, wenn Sie auf den Abschluss der Tasks warten möchten. Was ist, wenn Sie Ihren Thread Pool Executor nicht herunterfahren wollen/können? Dies ist eine empfohlene Methode:

ExecutorService exec = Executors.newFixedThreadPool(3); 
    Collection<Future<?>> tasks = new LinkedList<Future<?>>(); 

    Future<T> future = exec.submit(A); 
    tasks.add(future); 
    future = exec.submit(B); 
    tasks.add(future); 
    future = exec.submit(C); 
    tasks.add(future); 

    // wait for tasks completion 
    for (Future<?> currTask : tasks) { 
      try { 
       currTask.get(); 
      } catch (Throwable thrown) { 
       Logger.error(thrown, "Error while waiting for thread completion"); 
      } 
     }