使用 Completable Future 處理 Java 中的多執行緒

1. 理解完整的未來

CompletableFuture 是java.util.concurrent 套件的一部分，提供了一種以更具可讀性和可維護性的方式編寫非同步、非阻塞程式碼的方法。它代表非同步計算的未來結果。

1.1 建立一個簡單的CompletableFuture

從 CompletableFuture 開始，您可以建立一個簡單的非同步任務。這是一個例子：

import java.util.concurrent.CompletableFuture;

public class CompletableFutureExample {
    public static void main(String[] args) {
        CompletableFuture<void> future = CompletableFuture.runAsync(() -> {
            System.out.println("Running asynchronously...");
            // Simulate a long-running task
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        future.join(); // Wait for the task to complete
        System.out.println("Task completed.");
    }
}
</void>

• CompletableFuture.runAsync() 非同步執行任務。
• future.join() 阻塞主線程，直到任務完成。

示範結果：

Running asynchronously...
Task completed.

1.2 將 CompletableFuture 與結果結合使用

您也可以使用CompletableFuture傳回非同步任務的結果：

import java.util.concurrent.CompletableFuture;

public class CompletableFutureWithResult {
    public static void main(String[] args) {
        CompletableFuture<integer> future = CompletableFuture.supplyAsync(() -> {
            // Simulate a computation
            return 5 * 5;
        });

        future.thenAccept(result -> {
            System.out.println("The result is: " + result);
        }).join();
    }
}
</integer>

• CompletableFuture.supplyAsync() 用於傳回結果的任務。
• thenAccept() 計算完成後處理結果。

示範結果：

The result is: 25

2. 組合多個CompletableFuture

處理多個非同步任務是一個常見的用例。 CompletableFuture 提供了多種組合 future 的方法。

2.1 將 Future 與 thenCombine 結合起來

您可以組合多個 CompletableFutures 的結果：

import java.util.concurrent.CompletableFuture;

public class CombiningFutures {
    public static void main(String[] args) {
        CompletableFuture<integer> future1 = CompletableFuture.supplyAsync(() -> 5);
        CompletableFuture<integer> future2 = CompletableFuture.supplyAsync(() -> 10);

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

        combinedFuture.thenAccept(result -> {
            System.out.println("Combined result: " + result);
        }).join();
    }
}
</integer></integer></integer>

• thenCombine () 組合兩個 future 的結果。
• 使用 thenAccept () 處理組合結果。

示範結果：

Combined result: 15

2.2 使用 allOf 處理多個 Future

當需要等待多個 future 完成時，使用 CompletableFuture.allOf():

import java.util.concurrent.CompletableFuture;

public class AllOfExample {
    public static void main(String[] args) {
        CompletableFuture<void> future1 = CompletableFuture.runAsync(() -> {
            // Simulate task
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        CompletableFuture<void> future2 = CompletableFuture.runAsync(() -> {
            // Simulate another task
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        CompletableFuture<void> allOfFuture = CompletableFuture.allOf(future1, future2);

        allOfFuture.join();
        System.out.println("All tasks completed.");
    }
}
</void></void></void>

• CompletableFuture.allOf() 等待所有給定的 future 完成。
• join() 確保主執行緒等待，直到所有任務完成。

示範結果：

All tasks completed.

3. CompletableFuture 的錯誤處理

處理錯誤在非同步程式設計中至關重要。 CompletableFuture 提供了管理異常的方法。

3.1 使用異常處理異常

使用異常()處理非同步任務中的異常：

import java.util.concurrent.CompletableFuture;

public class ExceptionHandlingExample {
    public static void main(String[] args) {
        CompletableFuture<integer> future = CompletableFuture.supplyAsync(() -> {
            throw new RuntimeException("Something went wrong!");
        }).exceptionally(ex -> {
            System.out.println("Exception occurred: " + ex.getMessage());
            return null;
        });

        future.join();
    }
}
</integer>

• 異常 () 捕捉並處理異常。
• 它允許您提供後備結果或處理錯誤。

示範結果：

Exception occurred: Something went wrong!

4.CompletableFuture的優缺點

4.1 優點

• 非同步執行：高效處理並發運行的任務，而不阻塞主執行緒。
• 提高了可讀性：與傳統的回呼方法相比，提供了一種更具可讀性和可維護性的方式來處理非同步程式碼。
• 豐富的 API ：提供多種方法來組合、處理和組合多個 future。

4.2 缺點

• 複雜性：CompletableFuture 雖然功能強大，但會在管理和偵錯非同步程式碼時引入複雜性。
• 異常處理：處理異常有時可能很棘手，尤其是在具有多個階段的複雜場景中。

5. 結論

在本指南中，我們探討如何使用 CompletableFuture 處理 Java 中的並發請求。從建立簡單的非同步任務到組合多個 future 和處理錯誤，CompletableFuture 提供了一種健壯且靈活的非同步程式設計方法。

如果您有任何疑問或需要進一步協助，請隨時在下面發表評論。我很樂意提供協助！

閱讀更多文章：使用 Completable Future 處理 Java 中的多執行緒

以上是使用 Completable Future 處理 Java 中的多執行緒的詳細內容。更多資訊請關注PHP中文網其他相關文章！