Beherrschen des Herunterfahrens von ExecutorService: Verfolgen der ThreadPool-Beendigung

Angenommen, Sie möchten einige Aufgaben ausführen. Da es einige Zeit dauern kann, bis Sie das Ergebnis erhalten, wenn Sie es über einen einzelnen Thread ausführen, entscheiden Sie sich dafür, den stets zuverlässigen ExecutorService zu verwenden, um es über mehrere Threads zu verarbeiten.

Hier ist ein Beispiel:

public static void main(String[] args) {
    ExecutorService executorService = Executors.newFixedThreadPool(5);
    for (int i = 0; i < 5; i++) {
        int temp = i;
        executorService.submit(() -> {
            task(temp);
        });
    }
    executorService.shutdown();
    System.out.println("ExecutorService is shutdown");
}

private static void task(int temp) {
    try {
        TimeUnit.SECONDS.sleep(1L);
        System.out.println("Task " + temp + " completed");
    } catch (InterruptedException e) {
        throw new RuntimeException(e);
    }
}

Natürlich ist wie üblich kein Beispiel für Threads jemals vollständig, ohne „Schlaf“ als Archetyp der Aufgabenausführung zu verwenden.

Es wird ausgegeben,

ExecutorService is shutdown
Task 1 completed
Task 2 completed
Task 0 completed
Task 4 completed
Task 3 completed

Stellen Sie sich nun vor, es gäbe eine endlose Schlange an Aufgaben, deren Anzahl Sie nicht kennen. Möglicherweise werden sie durch die Anzahl der Einträge in einer Datenbank bestimmt, die dynamisch hinzugefügt werden.

Zum Beispiel eine Bank, die über den Tag verteilt eine Reihe von Transaktionen abwickeln muss. Die Endzeit der Transaktion ist 17:00 Uhr. Danach werden keine weiteren Aufgaben mehr angenommen.

Sie wissen jedoch, dass die Anzahl der Aufgaben begrenzt sein wird und irgendwann enden wird.

Woher wissen Sie, wann alle Aufgaben erledigt sind?

Wenn Sie den obigen Codeausschnitt bemerken, ermöglicht ExecutorService.shutdown() dem Hauptthread das sofortige Beenden, aber die Hintergrundthreads verarbeiten die akzeptierten Aufgaben weiterhin bis zum Abschluss. Gibt es eine Möglichkeit, über die Fertigstellung benachrichtigt zu werden?

Ein paar Lösungen fallen mir ein:

1. Verwenden Sie einen CountDownLatch, um die Aufgaben zu zählen. Da Sie jedoch die Anzahl der Aufgaben nicht kennen, ist die Verwendung unpraktisch.
2. Verwenden Sie ExecutorService.awaitTermination(). Allerdings ist die Zeit hier noch nicht deterministisch. Sie können ein sehr großzügiges ExecutorService.awaitTermination(Long.MAX_VALUE, TimeUnit.DAYS) oder etwas Ähnliches verwenden. Aber das ist wieder ein Sperrruf.

Gibt es einen besseren Weg, dieses Problem zu lösen?

Java bietet eine bessere und relativ unbekannte Möglichkeit, dies zu umgehen. Der „Trick“ besteht hier darin, zu wissen, dass Executors.newFixedThreadPool im Wesentlichen ein ThreadPoolExecutor mit vordefinierten Werten ist. Schauen wir uns die Implementierung von Executors.newFixedThreadPool an.

public static ExecutorService newFixedThreadPool(int nThreads) {
    return new ThreadPoolExecutor(nThreads, nThreads,
                                  0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<Runnable>());
}

Ich empfehle wirklich, das Dokument für ThreadPoolExecutor hier zu lesen. ExecutorService ist ein praktischer Wrapper über ThreadPoolExecutor.

... Programmierern wird dringend empfohlen, die bequemeren Executors-Factory-Methoden Executors.newCachedThreadPool() (unbegrenzter Thread-Pool mit automatischer Thread-Rückgewinnung), Executors.newFixedThreadPool(int) (Thread-Pool fester Größe) und Executors.newSingleThreadExecutor( ) (einzelner Hintergrundthread), der Einstellungen für die häufigsten Nutzungsszenarien vorkonfiguriert.

Der Abschnitt, der uns bei der Lösung des Problems hilft, ist:

Hook-Methoden

Diese Klasse stellt geschützte überschreibbare beforeExecute(Thread, Runnable)- und afterExecute(Runnable, Throwable)-Methoden bereit, die vor und nach der Ausführung jeder Aufgabe aufgerufen werden. Diese können verwendet werden, um die Ausführungsumgebung zu manipulieren; zum Beispiel die Neuinitialisierung von ThreadLocals, das Sammeln von Statistiken oder das Hinzufügen von Protokolleinträgen. Darüber hinaus kann die Methode „terminated()“ überschrieben werden, um eine spezielle Verarbeitung durchzuführen, die durchgeführt werden muss, sobald der Executor vollständig beendet wurde.

Wir können die beendete Methode verwenden, um uns darüber zu informieren! Aber wie nutzen wir es?

public static void main(String[] args) {
    ExecutorService executorService = Executors.newFixedThreadPool(5);
    for (int i = 0; i < 5; i++) {
        int temp = i;
        executorService.submit(() -> {
            task(temp);
        });
    }
    executorService.shutdown();
    System.out.println("ExecutorService is shutdown");
}

private static void task(int temp) {
    try {
        TimeUnit.SECONDS.sleep(1L);
        System.out.println("Task " + temp + " completed");
    } catch (InterruptedException e) {
        throw new RuntimeException(e);
    }
}

Wenn Sie keine anonymen Klassen bevorzugen (wie ich), können Sie ThreadPoolExecutor jederzeit selbst erweitern, um eine benutzerdefinierte Klasse zu erstellen.

ExecutorService is shutdown
Task 1 completed
Task 2 completed
Task 0 completed
Task 4 completed
Task 3 completed

Hier ist die Ausgabe, um zu überprüfen, ob es unseren Erwartungen entspricht.

public static ExecutorService newFixedThreadPool(int nThreads) {
    return new ThreadPoolExecutor(nThreads, nThreads,
                                  0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<Runnable>());
}

Welche anderen relativ unbekannten Snippets verwenden Sie? Lass es mich in den Kommentaren wissen!

Das obige ist der detaillierte Inhalt vonBeherrschen des Herunterfahrens von ExecutorService: Verfolgen der ThreadPool-Beendigung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!