Wie verwende ich Future und CompletableFuture in der Parallelität und im Multithreading von Java-Funktionen?

Future und CompletableFuture sind Tools für Parallelität und Multithreading in Java. Future stellt das Ergebnis der asynchronen Berechnung dar und stellt die Methode get () bereit, um den Thread zu blockieren und das Ergebnis zu erhalten. CompletableFuture erweitert Future, um umfassendere Funktionen bereitzustellen, z. B. das Kombinieren von Berechnungen, die Behandlung von Ausnahmen und die Verwendung von Rückruffunktionen. Nebenläufigkeit und Multithreading in Java-Funktionen: Verwendung von Future und CompletableFuture Sie ermöglichen Ihnen die Ausführung lang andauernder Vorgänge, ohne den Hauptthread zu blockieren, und verbessern so die Anwendungsleistung und Reaktionsfähigkeit.

Future

Future ist ein Objekt, das das Ergebnis einer asynchronen Berechnung darstellt. Es stellt eine Methode get() bereit, die den aktuellen Thread blockiert, bis das Ergebnis verfügbar ist. Sie können auch die Methode isDone() verwenden, um zu überprüfen, ob die Berechnung abgeschlossen ist.

CompletableFuture

Praktischer Fall

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class FileLoader {

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        Future<String> future = executorService.submit(() -> {
            // 异步加载文件
            return loadFile("file.txt");
        });

        // 继续执行其他任务，而不阻塞当前线程
        // ...

        // 当需要结果时，再阻塞主线程获取结果
        String result = future.get();
    }

    private static String loadFile(String filePath) {
        // 模拟文件加载操作
        return "File contents";
    }
}

CompletableFuture

CompletableFuture 是 Future 的扩展，提供了更丰富的功能。它允许您组合异步计算，处理异常，并使用回调函数。

实战案例

考虑以下示例，使用 Future 来异步加载文件：

import java.util.concurrent.CompletableFuture;

public class CompletableFutureExample {

    public static void main(String[] args) {
        // 定义第一个异步计算
        CompletableFuture<Integer> firstResult = CompletableFuture.supplyAsync(() -> {
            // 计算第一个结果
            return 5;
        });

        // 定义第二个异步计算
        CompletableFuture<Integer> secondResult = CompletableFuture.supplyAsync(() -> {
            // 计算第二个结果
            return 10;
        });

        // 组合两个计算，将它们的结果相加
        CompletableFuture<Integer> combinedResult = firstResult.thenCombine(secondResult, (x, y) -> x + y);

        // 获取最终结果
        int result = combinedResult.get();
    }
}

在这个示例中，我们使用 ExecutorService 创建了一个线程池，然后使用 submit() 提交了一个异步任务，该任务负责加载文件。主线程继续执行其他任务，而不阻塞等待文件加载完成。最后，当需要文件内容时，我们再调用 get() 从 Future 中获取结果。

使用 CompletableFuture

以下示例展示了如何使用 CompletableFuture 来组合异步计算：

在这个示例中，我们使用 CompletableFuture#supplyAsync() 创建了两个异步计算。然后，我们使用 CompletableFuture#thenCombine() 将它们组合起来，将它们的结果相加。最后，我们使用 CompletableFuture#get()In diesem Beispiel erstellen wir einen Thread-Pool mit ExecutorService und verwenden ihn dann submit() zum Senden einer asynchronen Aufgabe, die für das Laden der Datei verantwortlich ist. Der Hauptthread führt weiterhin andere Aufgaben aus, ohne das Warten auf das Laden der Datei zu blockieren. Wenn schließlich der Dateiinhalt benötigt wird, rufen wir get() auf, um das Ergebnis von Future abzurufen.

Das obige ist der detaillierte Inhalt vonWie verwende ich Future und CompletableFuture in der Parallelität und im Multithreading von Java-Funktionen?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!