Wie führe ich Aufgaben nicht blockierend mit Java Executors und CompletableFuture aus?

Nicht blockierende Aufgabenausführung mit Java-Executoren

Bei der Arbeit mit mehreren Aufgabenwarteschlangen ist es wichtig, blockierende Vorgänge zu vermeiden, die übermäßig viel verbrauchen können Stapelplatz. In diesem Artikel wird erläutert, wie Sie das java.util.concurrent-Paket von Java verwenden, um Aufgaben ohne Blockierung an einen Executor zu übermitteln und dabei Rückrufe für Benachrichtigungen über den Abschluss von Aufgaben zu nutzen.

Callback-Ansatz

Definieren eine Callback-Schnittstelle, die das gewünschte Ergebnis oder den Abschlussstatus der Aufgabe akzeptiert. Implementieren Sie eine Wrapper-Klasse, die sowohl die Aufgabe als auch den Rückruf akzeptiert. Wenn die Aufgabe abgeschlossen ist, ruft der Wrapper den Rückruf auf.

CompletableFuture und asynchrone Ausführung

Java 8 führte CompletableFuture ein, das einen ausgefeilteren Mechanismus zum asynchronen und bedingten Verfassen bietet Pipelines. Erstellen Sie eine CompletableFuture, die die Aufgabe in einem Thread-Pool ausführt. Hängen Sie dann einen Listener an die Zukunft an, der nach Abschluss der Aufgabe aufgerufen wird.

Beispiel

Der folgende Codeausschnitt demonstriert die Verwendung von CompletableFuture für die nicht blockierende Aufgabenausführung :

import java.util.concurrent.CompletableFuture;

// Service class to perform the task
class ExampleService {
    public String work() {
        // Simulated work
        char[] str = new char[5];
        ThreadLocalRandom current = ThreadLocalRandom.current();
        for (int idx = 0; idx < str.length; ++idx)
            str[idx] = (char) ('A' + current.nextInt(26));
        String msg = new String(str);
        System.out.println("Generated message: " + msg);
        return msg;
    }
}

// Main class
public class Main {
    public static void main(String[] args) {
        ExampleService svc = new ExampleService();
        CompletableFuture<String> f = CompletableFuture.supplyAsync(svc::work);
        
        // Attach a listener to the future
        f.thenAccept(result -> System.out.println("Result: " + result));
        
        // Main method can continue execution without blocking
        System.out.println("Main method exiting");
    }
}

Dieser Code erstellt eine CompletableFuture, die die work()-Methode asynchron ausführt. Die Methode thenAccept() fügt einen Listener an, der aufgerufen wird, wenn CompletableFuture abgeschlossen ist, und ermöglicht so eine nicht blockierende Ausführung der Aufgabe.

Das obige ist der detaillierte Inhalt vonWie führe ich Aufgaben nicht blockierend mit Java Executors und CompletableFuture aus?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!