本文將深入解析 CompletableFuture，希望對各位讀者能有所幫助。

CompletableFuture 適用于以下場景

• 并發(fā)執(zhí)行多個異步任務(wù)，等待它們?nèi)客瓿苫颢@取其中任意一個的結(jié)果。
• 對已有的異步任務(wù)進(jìn)行進(jìn)一步的轉(zhuǎn)換、組合和操作。
• 異步任務(wù)之間存在依賴關(guān)系，需要按照一定的順序進(jìn)行串行執(zhí)行。
• 需要對異步任務(wù)的結(jié)果進(jìn)行異常處理、超時控制或取消操作。

如何使用

下面是一個演示 CompletableFuture 如何使用的代碼示例：

public class CompletableFutureExample {

    public static void main(String[] args) {
        // 創(chuàng)建CompletableFuture對象，并定義異步任務(wù)
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
            // 異步任務(wù)的邏輯代碼
            // 在這里執(zhí)行耗時操作或其他需要異步執(zhí)行的任務(wù)
            try {
                TimeUnit.SECONDS.sleep(2); // 模擬耗時操作
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "Hello, ";
        });

        // 添加任務(wù)完成后的回調(diào)方法
        CompletableFuture<String> resultFuture = future.thenApplyAsync(result -> {
            // 任務(wù)完成后的處理邏輯
            // result為上一步任務(wù)的結(jié)果
            return result + "World!";
        });

        // 組合多個CompletableFuture對象
        CompletableFuture<String> combinedFuture = future.thenCombine(resultFuture, (result1, result2) -> {
            // 對多個CompletableFuture的結(jié)果進(jìn)行組合處理
            return result1 + result2 + " Welcome to the CompletableFuture world!";
        });

        // 異常處理
        CompletableFuture<String> exceptionHandledFuture = combinedFuture.exceptionally(ex -> {
            // 異常處理邏輯
            System.out.println("任務(wù)執(zhí)行出現(xiàn)異常：" + ex.getMessage());
            return "Fallback Result";
        });

        // 等待并獲取任務(wù)的結(jié)果
        try {
            String result = exceptionHandledFuture.get();
            System.out.println("任務(wù)的最終結(jié)果為：" + result);
        } catch (InterruptedException | ExecutionException e) {
            // 處理異常情況
            e.printStackTrace();
        }
    }
}

結(jié)果輸出：

任務(wù)的最終結(jié)果為：Hello, Hello, World! Welcome to the CompletableFuture world!

首先，我們創(chuàng)建了一個CompletableFuture對象future。在future中，我們使用supplyAsync方法定義了一個異步任務(wù)，其中 lambda表達(dá)式 中的代碼會在另一個線程中執(zhí)行。在這個例子中，我們模擬了一個耗時操作，通過TimeUnit.SECONDS.sleep(2)暫停了2秒鐘。

然后，我們添加了一個回調(diào)方法resultFuture。在這個回調(diào)方法中，將前一個異步任務(wù)的結(jié)果作為參數(shù)進(jìn)行處理，并返回處理后的新結(jié)果。在這個例子中，我們將前一個任務(wù)的結(jié)果與字符串 "World!" 連接起來，形成新的結(jié)果。

接下來，我們使用thenCombine方法組合了兩個CompletableFuture對象：future和resultFuture。在這個組合任務(wù)中，我們將兩個任務(wù)的結(jié)果進(jìn)行組合處理，返回最終的結(jié)果。在這個例子中，我們將前兩個任務(wù)的結(jié)果與字符串 " Welcome to the CompletableFuture world!" 連接起來。

此外，我們還處理了異常情況。通過exceptionally方法，我們定義了一個異常處理回調(diào)方法。如果在任務(wù)執(zhí)行過程中發(fā)生了異常，我們可以在這里對異常進(jìn)行處理，并返回一個默認(rèn)值作為結(jié)果。

最后，我們使用get方法等待并獲取最終的任務(wù)結(jié)果。需要注意的是，get方法可能會阻塞當(dāng)前線程，直到任務(wù)完成并返回結(jié)果。在這個例子中，我們使用try-catch塊捕獲可能的異常情況，并打印出最終的任務(wù)結(jié)果。

這個例子只是部分展示了CompletableFuture的功能，實際上它比你想象的還要強大！

源碼解析

CompletableFuture 的源碼非常龐大和復(fù)雜，涉及到并發(fā)、線程池、同步機制等多方面的知識。在這里，我們只重點介紹 CompletableFuture 的核心實現(xiàn)原理。

基本結(jié)構(gòu)

圖片

CompletableFuture 的作者是大名鼎鼎的 Doug Lea。CompletableFuture 類是實現(xiàn)了 Future 和 CompletionStage 接口的一個關(guān)鍵類。它可以表示異步計算的結(jié)果，并提供了一系列方法來操作和處理這些結(jié)果。

CompletableFuture 內(nèi)部使用了一個屬性result來保存計算結(jié)果，以及若干個屬性waiters來保存等待結(jié)果的任務(wù)。當(dāng)計算完成后，CompletableFuture將會通知所有等待結(jié)果的任務(wù)，并將結(jié)果傳遞給它們。

為了實現(xiàn)鏈?zhǔn)讲僮鳎珻ompletableFuture還定義了內(nèi)部類：Completion, UniCompletion, 和 BiCompletion。

Completion, UniCompletion, 和 BiCompletion 是 CompletableFuture 內(nèi)部用于處理異步任務(wù)完成的輔助類。

• Completion 是一個通用的輔助類，它包含了任務(wù)完成后的回調(diào)方法，以及處理異常的方法。
• UniCompletion 是 Completion 的子類，是一元依賴的基類，用于處理單個任務(wù)的完成情況，并提供了更多的方法來處理結(jié)果和異常。
• BiCompletion 是 UniCompletion 的子類，是二元依賴的基類，同時也是多元依賴的基類，用于處理兩個任務(wù)的完成情況，并提供了更多的方法來組合和處理這兩個任務(wù)的結(jié)果和異常。

這些輔助類在 CompletableFuture 的內(nèi)部被使用，以實現(xiàn)異步任務(wù)的執(zhí)行、結(jié)果的處理和組合等操作。它們提供了一種靈活的方式來處理異步任務(wù)的完成情況，并通過回調(diào)方法或其他一些方法來處理任務(wù)的結(jié)果和異常。

內(nèi)部原理

圖片

CompletableFuture中包含兩個字段：result 和 stack。result 用于存儲當(dāng)前CF的結(jié)果，stack (Completion）表示當(dāng)前CF完成后需要觸發(fā)的依賴動作(Dependency Actions)，去觸發(fā)依賴它的CF的計算，依賴動作可以有多個(表示有多個依賴它的CF)，以棧（Treiber stack）的形式存儲，stack表示棧頂元素。

CompletableFuture 在設(shè)計思想上類似 “觀察者模式，每個 CompletableFuture 都可以被看作一個被觀察者，其內(nèi)部有一個Completion類型的鏈表成員變量stack，用來存儲注冊到其中的所有觀察者。當(dāng)被觀察者執(zhí)行完成后會彈棧stack屬性，依次通知注冊到其中的觀察者。

執(zhí)行流程

CompletableFuture 的執(zhí)行流程如下：

1. 創(chuàng)建CompletableFuture對象：通過調(diào)用CompletableFuture類的構(gòu)造方法或靜態(tài)工廠方法創(chuàng)建一個新的CompletableFuture對象。
2. 定義異步任務(wù)：使用supplyAsync()、runAsync()等方法定義需要在后臺線程中執(zhí)行的異步任務(wù)，這些方法接受一個 lambda表達(dá)式 或 Supplier/Runnable 接口作為參數(shù)。
3. 啟動異步任務(wù)：一旦CompletableFuture對象創(chuàng)建并定義了異步任務(wù)，任務(wù)會立即在后臺線程中開始執(zhí)行，并返回一個代表異步計算結(jié)果的CompletableFuture對象。
4. 異步任務(wù)執(zhí)行過程：

當(dāng)異步任務(wù)完成時，它會設(shè)置自己的結(jié)果值，將狀態(tài)標(biāo)記為已完成。

如果有其他線程在此之前調(diào)用了complete()、completeExceptionally()、cancel()等方法，可能會影響任務(wù)的最終狀態(tài)。

5. 注冊回調(diào)方法：

• 使用thenApply(), thenAccept(), thenRun()等方法來注冊回調(diào)函數(shù)，當(dāng)異步任務(wù)完成或異常時，這些回調(diào)函數(shù)會被觸發(fā)。
• 回調(diào)函數(shù)也可以是異步的，通過thenApplyAsync(), thenAcceptAsync(), thenRunAsync()等方法注冊。

6. 組合多個CompletableFuture：

• 使用thenCompose(), thenCombine(), allOf(), anyOf()等方法，可以將多個CompletableFuture對象進(jìn)行組合，形成更復(fù)雜的異步任務(wù)處理流程。

7. 處理異常：

• 通過使用exceptionally(), handle(), whenComplete()等方法，可以注冊異常處理函數(shù)，當(dāng)異步任務(wù)出現(xiàn)異常時，這些處理函數(shù)會被觸發(fā)。

8. 等待結(jié)果：

• 使用get()或join()方法來阻塞當(dāng)前線程，并等待CompletableFuture對象的完成并獲取最終的結(jié)果。
• get()方法會拋出可能的異常（InterruptedException, ExecutionException）。
• join()方法與get()類似，但不會拋出 checked 異常。

9. 取消任務(wù)：通過調(diào)用CompletableFuture對象的cancel()方法取消異步任務(wù)的執(zhí)行。

請注意，以上步驟的順序和具體實現(xiàn)可能略有不同，但大致上反映了CompletableFuture的執(zhí)行流程。在實際應(yīng)用中，我們可以根據(jù)需求選擇適合的方法來處理異步任務(wù)的完成情況、結(jié)果、異常以及任務(wù)之間的關(guān)系。

方法介紹

CompletableFuture類提供了一系列用于處理和組合異步任務(wù)的方法。以下是這些方法的介紹：

創(chuàng)建對象

創(chuàng)建一個 CompletableFuture 對象有以下幾種方法：

• 使用 CompletableFuture 的構(gòu)造方法

CompletableFuture<String> future = new CompletableFuture<>();

• 使用 CompletableFuture 的靜態(tài)工廠方法

CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
    // 異步任務(wù)邏輯
    return "Result";
});

CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
    // 異步任務(wù)邏輯
});

• 使用轉(zhuǎn)換方法

CompletableFuture<Integer> transformedFuture = originalFuture.thenApply(result -> {
    // 轉(zhuǎn)換邏輯
    return result.length();
});

originalFuture.thenAccept(result -> {
    // 處理結(jié)果邏輯
    System.out.println("Result: " + result);
});

CompletableFuture<Void> runnableFuture = originalFuture.thenRun(() -> {
    // 在結(jié)果完成后執(zhí)行的操作
});

• 直接創(chuàng)建一個已完成狀態(tài)的CompletableFuture

//CompletableFuture.completedFuture()直接創(chuàng)建一個已完成狀態(tài)的CompletableFuture
CompletableFuture<String> cf2 = CompletableFuture.completedFuture("result");

//先初始化一個未完成的CompletableFuture，然后通過complete()、completeExceptionally()，也完成該CompletableFuture
CompletableFuture<String> cf = new CompletableFuture<>();
cf.complete("success");

• toCompletableFuture

CompletionStage<Integer> stage = CompletableFuture.supplyAsync(() -> 42);

CompletableFuture<Integer> future = stage.toCompletableFuture();

用于將當(dāng)前的 CompletionStage 對象轉(zhuǎn)換為一個 CompletableFuture 對象。

異步執(zhí)行任務(wù)

以下是在 CompletableFuture 對象上異步執(zhí)行任務(wù)的一些方法示例：

• supplyAsync(Supplier<U> supplier)：異步執(zhí)行一個有返回值的供應(yīng)商（Supplier）任務(wù)。

CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
    // 異步任務(wù)邏輯
    return "Result";
});

• runAsync(Runnable runnable)：異步執(zhí)行一個沒有返回值的任務(wù)。

CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
    // 異步任務(wù)邏輯
});

鏈?zhǔn)讲僮?/h3>

CompletableFuture提供了不同的方式來對異步任務(wù)進(jìn)行鏈?zhǔn)讲僮鳌?/p>

• thenRun

CompletableFuture<Void> executedFuture = future.thenRun(() -> executeTask());

thenRun方法用于在CompletableFuture完成后執(zhí)行一個Runnable任務(wù)。它返回一個新的CompletableFuture對象，該對象沒有返回值。

• thenAccept

CompletableFuture<Void> acceptedFuture = future.thenAccept(result -> processResult(result));

thenAccept方法用于在CompletableFuture完成后對結(jié)果進(jìn)行處理。它接收一個Consumer函數(shù)作為參數(shù)，并返回一個新的CompletableFuture對象。

• thenApply

CompletableFuture<U> appliedFuture = future.thenApply(result -> transformResult(result));

thenApply方法用于在CompletableFuture完成后對結(jié)果進(jìn)行轉(zhuǎn)換。它接收一個Function函數(shù)作為參數(shù)，并返回一個新的CompletableFuture對象。

• thenCompose

CompletableFuture<U> composedFuture = future.thenCompose(result -> executeAnotherTask(result));

用于對異步任務(wù)的結(jié)果進(jìn)行處理，并返回一個新的異步任務(wù)。

• whenComplete

CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> 42);

CompletableFuture<Void> whenCompleteFuture = future.whenComplete((result, exception) -> {
    if (exception != null) {
        System.out.println("Exception occurred: " + exception.getMessage());
    } else {
        System.out.println("Result: " + result);
    }
});

whenCompleteFuture.join();

用于在異步任務(wù)完成后執(zhí)行指定的動作。它允許你在任務(wù)完成時處理結(jié)果或處理異常。

• thenCompose() 用于對異步任務(wù)的結(jié)果進(jìn)行處理，并返回一個新的異步任務(wù)。它接受一個函數(shù)式接口參數(shù)，根據(jù)原始任務(wù)的結(jié)果創(chuàng)建并返回一個新的 CompletionStage 對象。
• whenComplete() 用于在異步任務(wù)完成后執(zhí)行指定的動作。它接受一個消費者函數(shù)式接口參數(shù)，用于處理任務(wù)的結(jié)果或異常，但沒有返回值。

異步任務(wù)組合

CompletableFuture還提供了一系列方法來組合和處理多個異步任務(wù)的結(jié)果。

• allOf

CompletableFuture<Void> allFuture = CompletableFuture.allOf(future1, future2, future3);

allOf方法接收一組CompletableFuture對象作為參數(shù)，并返回一個新的CompletableFuture對象，該對象在所有給定的CompletableFuture都完成時完成。這樣我們可以等待所有任務(wù)都完成后再進(jìn)行下一步操作。

• anyOf

CompletableFuture<Object> anyFuture = CompletableFuture.anyOf(future1, future2, future3);

anyOf方法與allOf類似，不同之處在于它返回的CompletableFuture對象在任何一個給定的CompletableFuture完成時就完成。這樣我們可以獲取最先完成的任務(wù)的結(jié)果。

• thenCombine

CompletableFuture<U> combinedFuture = future1.thenCombine(future2, (result1, result2) -> combineResults(result1, result2));

thenCombine方法接收兩個CompletableFuture對象和一個函數(shù)作為參數(shù)，用于指定當(dāng)這兩個CompletableFuture都完成時如何處理它們的結(jié)果。返回的新的CompletableFuture對象將接收到計算后的結(jié)果。

• applyToEither

CompletableFuture<U> resultFuture = future1.applyToEither(future2, result -> processResult(result));

applyToEither方法用于獲取兩個CompletableFuture中任意一個完成的結(jié)果，并對該結(jié)果進(jìn)行處理。它接收一個Function函數(shù)作為參數(shù)，并返回一個新的CompletableFuture對象。

• acceptEither

CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> 10);
CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> 20);

future1.acceptEither(future2, result -> {
    System.out.println("Result: " + result);
});

用于在兩個 CompletableFuture 對象中任意一個完成時執(zhí)行指定的操作。該方法接收兩個參數(shù)：另一個 CompletableFuture 對象和一個消費者函數(shù)（Consumer）。當(dāng)其中任何一個 CompletableFuture 完成時，將其結(jié)果作為參數(shù)傳遞給消費者函數(shù)進(jìn)行處理。

• runAfterBoth

CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> 42);
CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> "Hello");

CompletableFuture<Void> combinedFuture = future1.runAfterBoth(future2, () -> {
    System.out.println("Both futures completed");
});

combinedFuture.join();

用于在兩個異步任務(wù)都完成后執(zhí)行指定的動作，需要注意的是，runAfterBoth() 方法是一個非阻塞方法，動作將在兩個異步任務(wù)都完成后立即執(zhí)行。

• runAfterEither

CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
    try {
        Thread.sleep(500);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    return 42;
});

CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {
    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    return "Hello";
});

CompletableFuture<Void> eitherFuture = future1.runAfterEither(future2, () -> {
    System.out.println("One of the futures completed");
});

eitherFuture.join();

用于在兩個異步任務(wù)中任意一個完成后執(zhí)行指定的動作。

• thenAcceptBoth

CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> 42);
CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> "Hello");

CompletableFuture<Void> thenAcceptBothFuture = future1.thenAcceptBoth(future2, (result1, result2) -> {
    System.out.println("Action executed with thenAcceptBoth(): " + result1 + ", " + result2);
});

thenAcceptBothFuture.join();

用于在兩個異步任務(wù)都完成后執(zhí)行指定的動作。它的作用是接收兩個異步任務(wù)的結(jié)果，并將結(jié)果作為參數(shù)傳遞給指定的消費者函數(shù)。

異常處理

CompletableFuture提供了多種方式來處理異步任務(wù)的異常情況。

• exceptionally

CompletableFuture<U> exceptionHandledFuture = future.exceptionally(ex -> handleException(ex));

通過exceptionally方法，我們可以對CompletableFuture的異常情況進(jìn)行處理。它接收一個Function函數(shù)作為參數(shù)，用于處理異常并返回一個新的CompletableFuture對象。

• handle

CompletableFuture<U> handledFuture = future.handle((result, ex) -> handleResult(result, ex));

handle方法可以同時處理正常結(jié)果和異常情況。它接收一個BiFunction函數(shù)作為參數(shù)，用于處理結(jié)果和異常，并返回一個新的CompletableFuture對象。

• completeExceptionally

future.completeExceptionally();

異常地完成 CompletableFuture，將結(jié)果設(shè)置為一個異常。

• isCompletedExceptionally

CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
    throw new RuntimeException("Something went wrong");
});

boolean completedExceptionally = future.isCompletedExceptionally();
System.out.println("Is completed exceptionally: " + completedExceptionally);

該方法返回一個布爾值，表示當(dāng)前異步任務(wù)是否已經(jīng)異常完成。

• obtrudeException

CompletableFuture<Integer> future = new CompletableFuture<>();

future.obtrudeException(new RuntimeException("Something went wrong"));

boolean completedExceptionally = future.isCompletedExceptionally();
System.out.println("Is completed exceptionally: " + completedExceptionally);

用于強制將指定的異常作為異步任務(wù)的結(jié)果，調(diào)用 obtrudeException(Throwable ex) 方法后，異步任務(wù)將立即完成，并將指定的異常作為結(jié)果返回。

取值與狀態(tài)

• join

future.join()

join() 方法不會拋出已檢查異常，因為它是基于 CompletableFuture 類設(shè)計的，如果異步任務(wù)拋出異常，join() 方法會將該異常包裝在 CompletionException 中并拋出。

• get

future.get()

get() 方法會拋出一個 InterruptedException 異常和一個 ExecutionException 異常，前者表示獲取結(jié)果時被中斷，后者表示獲取結(jié)果時任務(wù)本身拋出了異常。

future.get(1,TimeUnit.Hours)

有異常則拋出異常，最長等待一個小時，一個小時之后，如果還沒有數(shù)據(jù)，則異常。

• getNow

CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
    // 異步任務(wù)邏輯
    return 42;
});

int result = future.getNow(0); // 獲取異步操作的結(jié)果，如果尚未完成，則返回默認(rèn)值0

System.out.println("Result: " + result);

getNow(T value) 是 CompletableFuture 類的一個方法，用于獲取異步操作的結(jié)果，如果異步操作尚未完成，則返回給定的默認(rèn)值，該方法會立即返回結(jié)果，不會阻塞當(dāng)前線程。

超時控制與取消操作

CompletableFuture也支持超時控制和取消操作，以便更好地管理異步任務(wù)的執(zhí)行。

• completeOnTimeout

CompletableFuture<U> timeoutFuture = future.completeOnTimeout(defaultResult, timeout, timeUnit);

completeOnTimeout方法在指定的超時時間內(nèi)等待CompletableFuture的完成，如果超時則將其設(shè)置為默認(rèn)結(jié)果。它返回一個新的CompletableFuture對象。

• cancel

boolean isCancelled = future.cancel(true);

cancel方法可用于取消CompletableFuture的執(zhí)行。它接收一個boolean參數(shù)，指示是否中斷正在執(zhí)行的任務(wù)。返回值表示是否成功取消了任務(wù)。

• isCancelled

CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
    // 異步任務(wù)邏輯
    return 42;
});

future.cancel(true); // 取消異步任務(wù)

boolean isCancelled = future.isCancelled();
System.out.println("Is cancelled: " + isCancelled);

isCancelled() 是 CompletableFuture 類的一個方法，用于判斷當(dāng)前異步任務(wù)是否已被取消。如果異步任務(wù)已被取消，則返回 true；否則返回 false。

依賴

• getNumberOfDependents

CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> 10);
CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> 20);

CompletableFuture<Integer> combinedFuture = future1.thenCombine(future2, (result1, result2) -> result1 + result2);

int numberOfDependents = combinedFuture.getNumberOfDependents();
System.out.println("Number of dependents: " + numberOfDependents);

getNumberOfDependents() 用于獲取當(dāng)前 CompletableFuture 對象所依賴的其他異步任務(wù)的數(shù)量。如果沒有任何依賴任務(wù)，或者所有依賴任務(wù)已經(jīng)完成，則返回的數(shù)量為0。

完成

• complete

future.complete("米飯");

complete(T value)：該方法返回布爾值，表示是否成功地將結(jié)果設(shè)置到 CompletableFuture 中。如果 CompletableFuture 未完成，則將結(jié)果設(shè)置，并返回 true；如果 CompletableFuture 已經(jīng)完成，則不進(jìn)行任何操作并返回 false。

• obtrudeValue

CompletableFuture<Integer> future = new CompletableFuture<>();

future.obtrudeValue(42);

boolean completedNormally = future.isDone() && !future.isCompletedExceptionally();
System.out.println("Is completed normally: " + completedNormally);

用于強制將指定的值作為異步任務(wù)的結(jié)果，調(diào)用 obtrudeValue(T value) 方法后，異步任務(wù)將立即完成，并將指定的值作為結(jié)果返回。

與 complete() 不同，obtrudeValue() 必須在任務(wù)已經(jīng)完成的情況下調(diào)用，否則會引發(fā) IllegalStateException 異常。并且complete() 方法對于已經(jīng)完成的任務(wù)會忽略額外的完成操作，并返回 false。而obtrudeValue() 方法即使任務(wù)已經(jīng)完成，仍然會強制使用新的結(jié)果值，并返回 true。

• isDone

CompletableFuture<Integer> future = CompletableFuture.completedFuture(42);

boolean done = future.isDone();
System.out.println("Is done: " + done);

用于判斷當(dāng)前異步任務(wù)是否已經(jīng)完成（無論是正常完成還是異常完成）。

并發(fā)限制

CompletableFuture也支持并發(fā)限制，以控制同時執(zhí)行的異步任務(wù)數(shù)量。

Executor executor = Executors.newFixedThreadPool(10);
CompletableFuture<U> future = CompletableFuture.supplyAsync(() -> doSomething(), executor);

我們可以通過使用線程池來限制CompletableFuture的并發(fā)執(zhí)行數(shù)量。通過創(chuàng)建一個固定大小的線程池，并將其作為參數(shù)傳遞給CompletableFuture，就可以控制并發(fā)執(zhí)行任務(wù)的數(shù)量。

記憶竅門

CompletableFuture類提供了許多方法，但實際上常用的方法只有幾個。為了方便記憶，以下是一些總結(jié)的規(guī)律：

• 方法名帶Async的都是異步方法，對應(yīng)的沒有Async則是同步方法，比如 thenAccept  與 thenAcceptAsync 。
• 方法名帶run的入?yún)镽unnable，且無返回值。
• 方法名帶supply的入?yún)镾upplier，且有返回值。
• 方法名帶Accept的入?yún)镃onsumer，且無返回值。
• 方法名帶Apply的入?yún)镕unction，且有返回值。
• 方法名帶Either的方法表示誰先完成就消費誰。
• 方法名帶Both的方法表示兩個任務(wù)都完成才消費。

掌握以上規(guī)律后，就可以基本記住大部分方法，剩下的其他方法可以單獨記憶。

總結(jié)

本文詳細(xì)探討了 CompletableFuture 的原理和方法，學(xué)習(xí)了如何在任務(wù)完成后執(zhí)行操作、處理結(jié)果和轉(zhuǎn)換結(jié)果。

CompletableFuture是Java中強大的異步編程工具之一，合理利用它的方法和策略可以更好地處理異步任務(wù)和操作。