ExecutorService, wie Sie warten, bis alle Aufgaben abgeschlossen sind

Was ist der einfachste Weg, um zu warten, bis alle Aufgaben erledigt sind ExecutorService? Meine Aufgabe ist in erster Linie rechnerisch, daher möchte ich nur eine große Anzahl von Jobs ausführen - einen auf jedem Kern. Im Moment sieht mein Setup so aus:

ExecutorService es = Executors.newFixedThreadPool(2);
for (DataTable singleTable : uniquePhrases) {   
    es.execute(new ComputeDTask(singleTable));
}
try{
    es.wait();
} 
catch (InterruptedException e){
    e.printStackTrace();
}

ComputeDTaskimplementiert lauffähig. Dies scheint die Aufgaben korrekt auszuführen, aber der Code stürzt wait()mit ab IllegalMonitorStateException. Das ist seltsam, weil ich mit einigen Spielzeugbeispielen herumgespielt habe und es schien zu funktionieren.

uniquePhrasesenthält mehrere Zehntausende von Elementen. Sollte ich eine andere Methode verwenden? Ich suche etwas so Einfaches wie möglich

Der einfachste Ansatz besteht darin, zu verwenden ExecutorService.invokeAll(), was in einem Einzeiler das tut, was Sie wollen. In Ihrer Sprache müssen Sie ComputeDTaskdie Implementierung ändern oder umbrechen Callable<>, was Ihnen einiges an Flexibilität geben kann. Wahrscheinlich gibt es in Ihrer App eine sinnvolle Implementierung von Callable.call(), aber hier ist eine Möglichkeit, sie zu verpacken, wenn Sie sie nicht verwenden Executors.callable().

ExecutorService es = Executors.newFixedThreadPool(2);
List<Callable<Object>> todo = new ArrayList<Callable<Object>>(singleTable.size());

for (DataTable singleTable: uniquePhrases) { 
    todo.add(Executors.callable(new ComputeDTask(singleTable))); 
}

List<Future<Object>> answers = es.invokeAll(todo);

Wie andere bereits betont haben, können Sie invokeAll()gegebenenfalls die Timeout-Version von verwenden . In diesem Beispiel answerswird es eine Reihe von Futures enthalten, die Nullen zurückgeben (siehe Definition von Executors.callable(). Wahrscheinlich möchten Sie ein leichtes Refactoring durchführen, damit Sie eine nützliche Antwort oder einen Verweis auf den zugrunde liegenden Wert erhalten ComputeDTask, aber ich kann Erzählen Sie nicht von Ihrem Beispiel.

Wenn es nicht klar ist, beachten Sie, dass invokeAll()es nicht zurückkehrt, bis alle Aufgaben abgeschlossen sind. (Das heißt, alle Futures in Ihrer answersSammlung werden gemeldet, .isDone()wenn Sie dazu aufgefordert werden.) Dies vermeidet das manuelle Herunterfahren, Warten auf Beendigung usw. und ermöglicht es Ihnen, dies bei ExecutorServiceBedarf für mehrere Zyklen sauber wiederzuverwenden .

Es gibt einige verwandte Fragen zu SO:

• So warten Sie, bis alle Threads abgeschlossen sind

• Rückgabewerte von Java-Threads

• invokeAll () ist nicht bereit, eine Sammlung <Callable <t>> zu akzeptieren

• Muss ich synchronisieren?

Keines davon ist genau auf Ihre Frage zugeschnitten, aber es liefert ein wenig Farbe darüber, wie Leute denken Executor/ verwendet ExecutorServicewerden sollten.

Wenn Sie warten möchten, bis alle Aufgaben abgeschlossen sind, verwenden Sie shutdownstattdessen die Methode wait. Dann folgen Sie ihm mit awaitTermination.

Außerdem können Sie Runtime.availableProcessorsdie Anzahl der Hardware-Threads abrufen, um Ihren Threadpool ordnungsgemäß zu initialisieren.

Wenn das Warten auf das ExecutorServiceBeenden aller Aufgaben im Ziel nicht genau Ihr Ziel ist, sondern das Warten, bis ein bestimmter Stapel von Aufgaben abgeschlossen ist, können Sie ein CompletionService- speziell ein ExecutorCompletionService.

Die Idee ist, eine ExecutorCompletionServiceVerpackung zu erstellen Executor, einreichen einige bekannte Anzahl von Aufgaben durch die CompletionService, dann ist das Zeichnen derselben Anzahl von Ergebnissen aus dem Abschluss - Warteschlange unter Verwendung von entweder take()(die Blöcke) oder poll()(was nicht). Sobald Sie alle erwarteten Ergebnisse für die von Ihnen eingereichten Aufgaben gezeichnet haben, wissen Sie, dass alle erledigt sind.

Lassen Sie mich dies noch einmal sagen, da es aus der Benutzeroberfläche nicht ersichtlich ist: Sie müssen wissen, wie viele Dinge Sie in das CompletionServiceeingeben, um zu wissen, wie viele Dinge Sie herausziehen möchten. Dies ist besonders bei der take()Methode von Bedeutung: Rufen Sie sie einmal zu oft auf, und Ihr aufrufender Thread wird blockiert, bis ein anderer Thread einen anderen Job an denselben sendet CompletionService.

Es gibt einige Beispiele, die zeigen, wieCompletionService das Buch Java Concurrency in der Praxis verwendet wird .

Wenn Sie warten möchten, bis der Executor-Service die Ausführung beendet hat, rufen Sie an und warten Sie shutdown()dann auf Terminierung (Einheiten, Einheitentyp) , z awaitTermination(1, MINUTE). Der ExecutorService blockiert nicht auf seinem eigenen Monitor, sodass Sie waitusw. nicht verwenden können .

Sie können warten, bis die Jobs in einem bestimmten Intervall beendet sind:

int maxSecondsPerComputeDTask = 20;
try {
    while (!es.awaitTermination(uniquePhrases.size() * maxSecondsPerComputeDTask, TimeUnit.SECONDS)) {
        // consider giving up with a 'break' statement under certain conditions
    }
} catch (InterruptedException e) {
    throw new RuntimeException(e);    
}

Oder Sie könnten ExecutorService verwenden . einreichen ( Runnable ) und sammeln Sie die Zukunft Objekte , die es gibt und Call get () auf jedem wiederum zu warten , bis sie zu beenden.

ExecutorService es = Executors.newFixedThreadPool(2);
Collection<Future<?>> futures = new LinkedList<<Future<?>>();
for (DataTable singleTable : uniquePhrases) {
    futures.add(es.submit(new ComputeDTask(singleTable)));
}
for (Future<?> future : futures) {
   try {
       future.get();
   } catch (InterruptedException e) {
       throw new RuntimeException(e);
   } catch (ExecutionException e) {
       throw new RuntimeException(e);
   }
}

InterruptedException ist äußerst wichtig, um richtig zu handeln. Auf diese Weise können Sie oder die Benutzer Ihrer Bibliothek einen langen Prozess sicher beenden.

Benutz einfach

latch = new CountDownLatch(noThreads)

In jedem Thread

latch.countDown();

und als Barriere

latch.await();

Grundursache für die IllegalMonitorStateException :

Wird ausgelöst, um anzuzeigen, dass ein Thread versucht hat, auf dem Monitor eines Objekts zu warten, oder um andere Threads zu benachrichtigen, die auf dem Monitor eines Objekts warten, ohne den angegebenen Monitor zu besitzen.

Von Ihrem Code aus haben Sie gerade wait () für ExecutorService aufgerufen, ohne die Sperre zu besitzen.

Der folgende Code wird behoben IllegalMonitorStateException

try 
{
    synchronized(es){
        es.wait(); // Add some condition before you call wait()
    }
} 

Befolgen Sie einen der folgenden Ansätze, um auf die Fertigstellung aller Aufgaben zu warten, die an gesendet wurden ExecutorService.

1. Durchlaufen Sie alle FutureAufgaben von Anfang submitan ExecutorServiceund überprüfen Sie den Status, indem Sie den Aufruf get()des FutureObjekts blockieren

2. Verwenden von invokeAll onExecutorService

3. Mit CountDownLatch

4. Verwenden von ForkJoinPool oder newWorkStealingPool von Executors(seit Java 8)

5. Shutdown der Pool wie in der Oracle - Dokumentation empfohlen Seite

   void shutdownAndAwaitTermination(ExecutorService pool) {
      pool.shutdown(); // Disable new tasks from being submitted
      try {
      // Wait a while for existing tasks to terminate
      if (!pool.awaitTermination(60, TimeUnit.SECONDS)) {
          pool.shutdownNow(); // Cancel currently executing tasks
          // Wait a while for tasks to respond to being cancelled
          if (!pool.awaitTermination(60, TimeUnit.SECONDS))
          System.err.println("Pool did not terminate");
      }
   } catch (InterruptedException ie) {
        // (Re-)Cancel if current thread also interrupted
        pool.shutdownNow();
        // Preserve interrupt status
        Thread.currentThread().interrupt();
   }

   Wenn Sie ordnungsgemäß auf den Abschluss aller Aufgaben warten möchten, wenn Sie Option 5 anstelle der Optionen 1 bis 4 verwenden, ändern Sie diese

   if (!pool.awaitTermination(60, TimeUnit.SECONDS)) {

   zu

   a, while(condition)die alle 1 Minute überprüft.

Sie können die ExecutorService.invokeAllMethode verwenden. Sie führt alle Aufgaben aus und wartet, bis alle Threads ihre Aufgabe beendet haben.

Hier ist komplettes Javadoc

Sie können auch eine überladene Version dieser Methode verwenden, um das Zeitlimit anzugeben.

Hier ist Beispielcode mit ExecutorService.invokeAll

public class Test {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        ExecutorService service = Executors.newFixedThreadPool(3);
        List<Callable<String>> taskList = new ArrayList<>();
        taskList.add(new Task1());
        taskList.add(new Task2());
        List<Future<String>> results = service.invokeAll(taskList);
        for (Future<String> f : results) {
            System.out.println(f.get());
        }
    }

}

class Task1 implements Callable<String> {
    @Override
    public String call() throws Exception {
        try {
            Thread.sleep(2000);
            return "Task 1 done";
        } catch (Exception e) {
            e.printStackTrace();
            return " error in task1";
        }
    }
}

class Task2 implements Callable<String> {
    @Override
    public String call() throws Exception {
        try {
            Thread.sleep(3000);
            return "Task 2 done";
        } catch (Exception e) {
            e.printStackTrace();
            return " error in task2";
        }
    }
}

Ich habe auch die Situation, dass ich eine Reihe von Dokumenten zum Crawlen habe. Ich beginne mit einem anfänglichen "Seed" -Dokument, das verarbeitet werden soll. Dieses Dokument enthält Links zu anderen Dokumenten, die ebenfalls verarbeitet werden sollen, und so weiter.

In meinem Hauptprogramm möchte ich nur Folgendes schreiben, in dem Crawlereine Reihe von Threads gesteuert werden.

Crawler c = new Crawler();
c.schedule(seedDocument); 
c.waitUntilCompletion()

Die gleiche Situation würde passieren, wenn ich durch einen Baum navigieren wollte; Ich würde den Stammknoten einfügen, der Prozessor für jeden Knoten würde der Warteschlange nach Bedarf untergeordnete Elemente hinzufügen, und eine Reihe von Threads würde alle Knoten im Baum verarbeiten, bis keine mehr vorhanden wären.

Ich konnte in der JVM nichts finden, was ich etwas überraschend fand. Also habe ich eine Klasse geschrieben, ThreadPooldie man entweder direkt oder in einer Unterklasse verwenden kann, um für die Domäne geeignete Methoden hinzuzufügen, z schedule(Document). Ich hoffe es hilft!

ThreadPool Javadoc | Maven

Fügen Sie alle Threads in der Sammlung hinzu und senden Sie sie mit invokeAll. Wenn Sie die invokeAllMethode von verwenden können ExecutorService, fährt JVM erst mit der nächsten Zeile fort, wenn alle Threads abgeschlossen sind.

Hier gibt es ein gutes Beispiel: invokeAll via ExecutorService

Senden Sie Ihre Aufgaben an den Runner und warten Sie, bis Sie die Methode waitTillDone () wie folgt aufrufen :

Runner runner = Runner.runner(2);

for (DataTable singleTable : uniquePhrases) {

    runner.run(new ComputeDTask(singleTable));
}

// blocks until all tasks are finished (or failed)
runner.waitTillDone();

runner.shutdown();

Um es zu verwenden, fügen Sie diese Gradle / Maven-Abhängigkeit hinzu: 'com.github.matejtymes:javafixes:1.0'

Weitere Informationen finden Sie hier: https://github.com/MatejTymes/JavaFixes oder hier: http://matejtymes.blogspot.com/2016/04/executor-that-notifications-you-when-task.html

Eine einfache Alternative dazu ist die Verwendung von Threads zusammen mit Join. Siehe: Threads verbinden

Ich werde nur warten, bis der Executor mit einem festgelegten Timeout beendet ist, das Ihrer Meinung nach für die Ausführung der Aufgaben geeignet ist.

 try {  
         //do stuff here 
         exe.execute(thread);
    } finally {
        exe.shutdown();
    }
    boolean result = exe.awaitTermination(4, TimeUnit.HOURS);
    if (!result)

    {
        LOGGER.error("It took more than 4 hour for the executor to stop, this shouldn't be the normal behaviour.");
    }

Klingt so, als ob Sie ForkJoinPoolden globalen Pool benötigen und verwenden, um Aufgaben auszuführen.

public static void main(String[] args) {
    // the default `commonPool` should be sufficient for many cases.
    ForkJoinPool pool = ForkJoinPool.commonPool(); 
    // The root of your task that may spawn other tasks. 
    // Make sure it submits the additional tasks to the same executor that it is in.
    Runnable rootTask = new YourTask(pool); 
    pool.execute(rootTask);
    pool.awaitQuiescence(...);
    // that's it.
}

Das Schöne ist, pool.awaitQuiescencedass die Methode den Thread des Aufrufers blockiert, um seine Aufgaben auszuführen, und dann zurückkehrt, wenn er wirklich leer ist.