ExecutorService-Schnittstelle

Warum benötigen Sie die Executor-Schnittstelle?

Vor Java 5 mussten Sie die gesamte Code-Thread-Verwaltung in Ihrer Anwendung selbst schreiben. Darüber hinaus ist die Erstellung einerneues Themaobject ist ein ressourcenintensiver Vorgang und es macht keinen Sinn, für jede einfache Aufgabe einen neuen Thread zu erstellen. Und weil dieses Problem absolut jedem Entwickler von Multithread-Anwendungen bekannt ist, haben sie beschlossen, diese Funktionalität als Executor- Framework in Java zu integrieren.

Was ist die große Idee? Es ist ganz einfach: Anstatt für jede neue Aufgabe einen neuen Thread zu erstellen, werden Threads in einer Art „Speicher“ aufbewahrt, und wenn eine neue Aufgabe eintrifft, rufen wir einen vorhandenen Thread ab, anstatt einen neuen zu erstellen.

Die Hauptschnittstellen dieses Frameworks sind Executor , ExecutorService und ScheduledExecutorService , von denen jede die Funktionalität der vorherigen erweitert.

Die Executor-Schnittstelle ist die Basisschnittstelle. Es deklariert eine einzelne void-execute-Methode (ausführbarer Befehl) , die von einem ausführbaren Objekt implementiert wird .

Interessanter ist die ExecutorService- Schnittstelle. Es verfügt über Methoden zur Verwaltung des Arbeitsabschlusses sowie über Methoden zur Rückgabe bestimmter Ergebnisse. Schauen wir uns seine Methoden genauer an:

Schauen wir uns ein kleines Beispiel für die Arbeit mit ExecutorService an .

import java.util.List;
import java.util.concurrent.*;

public class ExecutorServiceTest {
   public static void main(String[] args) throws InterruptedException, ExecutionException, TimeoutException {
//Create an ExecutorService for 2 threads
       java.util.concurrent.ExecutorService executorService = new ThreadPoolExecutor(2, 2, 60, TimeUnit.SECONDS, new ArrayBlockingQueue<>(10));
// Create 5 tasks
       MyRunnable task1 = new MyRunnable();
       MyRunnable task2 = new MyRunnable();
       MyRunnable task3 = new MyRunnable();
       MyRunnable task4 = new MyRunnable();
       MyRunnable task5 = new MyRunnable();

       final List<MyRunnable> tasks = List.of(task1, task2, task3, task4, task5);
// Pass a list that contains the 5 tasks we created
       final List<Future<Void>> futures = executorService.invokeAll(tasks, 6, TimeUnit.SECONDS);
       System.out.println("Futures received");

// Stop the ExecutorService
       executorService.shutdown();

       try {
           TimeUnit.SECONDS.sleep(3);
       } catch (InterruptedException e) {
           e.printStackTrace();
       }

       System.out.println(executorService.isShutdown());
       System.out.println(executorService.isTerminated());
   }

   public static class MyRunnable implements Callable<Void> {

       @Override
       public void call() {
// Add 2 delays. When the ExecutorService is stopped, we will see which delay is in progress when the attempt is made to stop execution of the task
           try {
               TimeUnit.SECONDS.sleep(3);
           } catch (InterruptedException e) {
               System.out.println("sleep 1: " + e.getMessage());
           }
           try {
               TimeUnit.SECONDS.sleep(2);
           } catch (InterruptedException e) {
               System.out.println("sleep 2: " + e.getMessage());
           }
           System.out.println("done");
           return null;
       }
   }
}

Ausgang:

Jede Aufgabe wird 5 Sekunden lang ausgeführt. Wir haben einen Pool für zwei Threads erstellt, daher sind die ersten beiden Ausgabezeilen absolut sinnvoll.

Sechs Sekunden nach dem Start des Programms läuft die Methode invokeAll ab und das Ergebnis wird als Liste von Futures zurückgegeben . Dies ist aus der Ausgabezeichenfolge „Futures empfangen“ ersichtlich .

Nachdem die ersten beiden Aufgaben erledigt sind, beginnen zwei weitere. Da jedoch das in der invokeAll- Methode festgelegte Zeitlimit abläuft, haben diese beiden Aufgaben keine Zeit zum Abschluss. Sie erhalten einen „Abbrechen“ -Befehl. Aus diesem Grund gibt es in der Ausgabe zwei Zeilen mit Sleep 1: Sleep Interrupted .

Und dann sehen Sie zwei weitere Zeilen mit done . Dies ist der Nebeneffekt, den ich bei der Beschreibung der invokeAll- Methode erwähnt habe.

Die fünfte und letzte Aufgabe wird nie gestartet, daher sehen wir in der Ausgabe nichts davon.

Die letzten beiden Zeilen sind das Ergebnis des Aufrufs der Methoden isShutdown und isTerminated .

Es ist auch interessant, dieses Beispiel im Debug-Modus auszuführen und sich den Aufgabenstatus nach Ablauf des Timeouts anzusehen (setzen Sie einen Haltepunkt in der Zeile mit executorService.shutdown(); ):

Wir sehen, dass zwei Aufgaben normal abgeschlossen wurden und drei Aufgaben „abgebrochen“ wurden .

ScheduledExecutorService

Um unsere Diskussion über Executoren abzuschließen, werfen wir einen Blick auf ScheduledExecutorService .

Es gibt 4 Methoden: