Übersicht über den Executor-Service in Java

Die Executor- und ExecutorService-API ist ein wichtiges Tool zum Verwalten und Steuern der Thread-Ausführung. Sie sind Teil des Pakets java.util.concurrent. Sie vereinfachen den Prozess der gleichzeitigen Programmierung, indem sie die Komplexität der Thread-Erstellung, -Verwaltung und -Synchronisierung abstrahieren.

Executors ist eine Dienstprogrammklasse aus dem Paket java.util.concurrent, die Factory-Methoden zum Erstellen und Verwalten verschiedener Arten von ExecutorService-Instanzen bereitstellt. Es vereinfacht den Prozess der Erstellung von Thread-Pools und ermöglicht uns die einfache Erstellung und Verwaltung von Executor-Instanzen mit unterschiedlichen Konfigurationen.

Executor API Es handelt sich um eine Schnittstelle, die seit Java 1.5 verfügbar ist. Es stellt die Methode „execute“ (ausführbarer Befehl) bereit. Dies ist die Basisschnittstelle und ExecutorService erweitert diese Schnittstelle. Der angegebene Befehl wird in Zukunft von einem neuen Thread oder Thread aus dem Thread-Pool oder demselben Thread ausgeführt und gibt nicht „void“ zurück.

ExecutorService API Es handelt sich um eine Schnittstelle, die seit Java 1.5 verfügbar ist. Es bietet mehrere Methoden zur Steuerung der Ausführung von Aufgaben bei der gleichzeitigen Programmierung. Es unterstützt sowohl ausführbare als auch aufrufbare Aufgaben. Es gibt Zukunft für den Aufgabenstatus zurück. Nachfolgend sind die am häufigsten verwendeten Methoden aufgeführt.

• submit() akzeptiert eine Callable- oder Runnable-Aufgabe und gibt ein Ergebnis vom Typ Future zurück.

• invokeAny() akzeptiert eine Sammlung von auszuführenden Aufgaben und gibt das Ergebnis einer erfolgreichen Ausführung einer beliebigen Aufgabe zurück.

• invokeAll() akzeptiert eine Sammlung von auszuführenden Aufgaben und gibt das Ergebnis aller Aufgaben in Form einer Liste vom Typ „Zukünftige Objekte“ zurück.

• shutdown() stoppt den Executor-Dienst nicht sofort, akzeptiert aber keine neuen Aufgaben. Sobald alle aktuell ausgeführten Aufgaben abgeschlossen sind, wird der Executor-Dienst heruntergefahren.

• shutdownNow() versucht, den Executor-Dienst sofort zu stoppen, es kann jedoch nicht garantiert werden, dass alle laufenden Aufgaben gleichzeitig gestoppt werden.

• awaitTermination(long timeout, TimeUnit-Einheit) blockiert/wartet, bis alle Aufgaben abgeschlossen sind oder eine Zeitüberschreitung auftritt oder der aktuelle Thread unterbrochen wird, je nachdem, was zuerst eintritt. Der aktuelle Thread wird blockiert.

Arten von ExecutorService

• FixedThreadPool Es erstellt einen Thread-Pool fester Größe mit einer angegebenen Anzahl von Threads. Übermittelte Aufgaben werden gleichzeitig ausgeführt. Wenn keine Aufgaben vorhanden sind, bleiben die Threads inaktiv, bis die Aufgabe eintrifft. Wenn Threads ausgelastet sind, werden Aufgaben in die Warteschlange gestellt.

ExecutorService fixedThreadPool = Executors.newScheduledThreadPool(5);
Future<String> submit = fixedThreadPool.submit(() -> {
    System.out.println("Task executed by " + Thread.currentThread().getName());
    return Thread.currentThread().getName();
});
fixedThreadPool.shutdown();

• CachedThreadPool Erstellt einen Thread-Pool und passt die Anzahl der im Pool erforderlichen Threads basierend auf der Arbeitslast automatisch an. Wenn der Thread länger als 60 Sekunden im Leerlauf ist, wird er beendet. Dies funktioniert gut bei dynamischen Belastungen. Da Threads nach einer Leerlaufzeitüberschreitung beendet werden, werden die Ressourcen hier besser genutzt.

ExecutorService fixedThreadPool = Executors.newCachedThreadPool();
Future<String> submit = fixedThreadPool.submit(() -> {
    System.out.println("Task executed by " + Thread.currentThread().getName());
    return Thread.currentThread().getName();
});
fixedThreadPool.shutdown();

• SingleThreadExecutor Erstellt einen einzelnen Thread und Aufgaben werden nacheinander ausgeführt. Eine Parallelverarbeitung findet hier nicht statt.

ExecutorService fixedThreadPool = Executors.newSingleThreadExecutor();
Future<String> submit = fixedThreadPool.submit(() -> {
    System.out.println("Task executed by " + Thread.currentThread().getName());
    return Thread.currentThread().getName();
});
fixedThreadPool.shutdown()

• ScheduledThreadPool/ScheduledExecutor Erstellt einen Thread oder Trhead-Pool, der die Aufgaben in regelmäßigen Abständen oder nach einer bestimmten Verzögerung ausführen kann.

ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor(); // Single-threaded scheduler
ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(5); // Multi-threaded scheduler

scheduler.schedule(task, 10, TimeUnit.SECONDS); // Schedule task to run after 10 seconds.

scheduler.scheduleAtFixedRate(task, 5, 10, TimeUnit.SECONDS);
    //It schedules a task to run every 10 seconds with an initial delay of 5 seconds.
scheduler.scheduleWithFixedDelay(task, 5, 10, TimeUnit.SECONDS);
   //It schedules a task to run with a fixed delay of 10 seconds between the end of one execution and the start of the next, with an initial delay of 5 seconds.
scheduler.schedule(() -> scheduler.shutdown(), 20, TimeUnit.SECONDS);
   //It schedules a shutdown of the scheduler after 20 seconds to stop the example.

Aufgaben an ExecutorService senden
Aufgaben können mit den Methoden „execute()“ und „submit()“ an den ExecutorService übermittelt werden. Die Methode „execute()“ wird für ausführbare Aufgaben verwendet, während „submit()“ sowohl ausführbare als auch aufrufbare Aufgaben verarbeiten kann.“

 executor.execute(new RunnableTask()); //fire-and-forgot
 executor.submit(new CallableTask()); //returns the status of task

ExecutorService wird heruntergefahren
Es ist wichtig, den ExecutorService herunterzufahren, um Ressourcen freizugeben. Sie können dies mit den Methoden „shutdown()“ und „shutdownNow()“ tun.

executor.shutdown(); // Initiates an orderly shutdown"
executor.shutdownNow(); // Attempts to stop all actively executing tasks.
executor.awaitTermination(long timeout, TimeUnit unit); //blocks the thread until all tasks are completed or timeout occurs or current thread is interrupted, whichever happens first. Returns `true `is tasks completed, otherwise `false`.

Empfohlener Ansatz zum Herunterfahren

executor.shutdown();
try {
    // Wait for tasks to complete or timeout
    if (!executor.awaitTermination(120, TimeUnit.SECONDS)) {
        // If the timeout occurs, force shutdown
        executor.shutdownNow();      
    }
} catch (InterruptedException ex) {
    executor.shutdownNow();
    Thread.currentThread().interrupt();
}

Über Runnable

• Runnable ist eine Schnittstelle und stellt eine Aufgabe dar, die von Threads ausgeführt werden kann.
• Wir können ausführbare Aufgaben mithilfe von Threads oder dem Executor-Dienst ausführen.
• Runnable verfügt über die run()-Methode und gibt keine Daten zurück.
• Wir können keine geprüfte Ausnahme auslösen.

Über Callable

• Es wird in 1.5 eingeführt
• Es verfügt über die Methode call() und gibt Typ V zurück.
• Es enthält Ausnahmen, was bedeutet, dass wir geprüfte Ausnahmen auslösen können.

Über die Zukunft

• Es stellt ein zukünftiges Ergebnis einer beliebigen Aufgabe dar.
• Das Ergebnis wird schließlich in der Zukunft angezeigt, nachdem die Bearbeitung der Anfrage abgeschlossen ist.
• boolean isDone() Gibt den Status der Anforderungsverarbeitung zurück. True, wenn ausgefüllt, andernfalls false.
• boolean cancel(boolean mayInterruptIfRunning) Bricht die übermittelte Aufgabe ab. Wenn wir mayInterruptIfRunning als false übergeben, wird eine bereits gestartete Aufgabe nicht abgebrochen.
• boolean isCancelled() gibt zurück, dass die Aufgabe abgebrochen wurde oder nicht.
• V get() gibt das Ergebnis der Aufgabe zurück. Blockiert den Thread, wenn die Aufgabe nicht abgeschlossen ist.
• V get(long timeout, TimeUnit-Einheit) Wartet bei Bedarf höchstens die angegebene Zeit, bis die Berechnung abgeschlossen ist, und ruft dann das Ergebnis ab. TimeoutException wird nach der angegebenen Zeit ausgelöst, wenn die Berechnung nicht abgeschlossen ist.

Viel Spaß beim Programmieren und Lernen !!!

Bitte hinterlassen Sie einen Kommentar, wenn Sie Fragen haben.

Das obige ist der detaillierte Inhalt vonÜbersicht über den Executor-Service in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!