Java中的非同步程式設計與CompletableFuture應用

Java中的非同步程式設計與CompletableFuture應用

大家好，我是微賺淘客系統3.0的小編，是個冬天不穿秋褲，天冷也要風度的程式猿！

在現代 Java 程式設計中，非同步程式設計變得越來越重要，它可以幫助我們提高應用程式的響應速度和效能。CompletableFuture 是 Java 8 引入的一個強大工具，它簡化了非同步程式設計，使得編寫非阻塞程式碼變得更加容易。本文將詳細介紹 CompletableFuture 的基本用法及其在實際開發中的應用。

1. 引入 CompletableFuture

CompletableFuture 是 java.util.concurrent 包的一部分，提供了在完成計算後可以操作的 Future 版本。它支援非同步程式設計、鏈式呼叫、組合多個非同步操作等功能。首先，我們需要在專案中確保使用 Java 8 或更高版本。

2. 建立 CompletableFuture

可以透過靜態方法 CompletableFuture.supplyAsync() 建立一個非同步任務。以下是一個基本的示例：

package cn.juwatech.completablefuture;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

public class BasicUsage {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(2000); // 模擬長時間執行的任務
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "Hello, CompletableFuture!";
        });

        // 阻塞直到計算完成並獲得結果
        String result = future.get();
        System.out.println("Result: " + result);
    }
}

3. 鏈式呼叫

CompletableFuture 支援鏈式呼叫，可以在一個任務完成後繼續執行其他任務。例如：

package cn.juwatech.completablefuture;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

public class Chaining {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        CompletableFuture.supplyAsync(() -> {
            return "Hello";
        }).thenApply(result -> {
            return result + ", World";
        }).thenAccept(System.out::println);
    }
}

在這個例子中，thenApply() 方法接收前一個階段的結果，並返回一個新的結果。thenAccept() 方法用來處理最終結果，但不返回任何值。

4. 異常處理

CompletableFuture 提供了異常處理的方法，例如 exceptionally()，用於處理計算過程中出現的異常：

package cn.juwatech.completablefuture;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

public class ExceptionHandling {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
            if (true) { // 模擬異常情況
                throw new RuntimeException("Something went wrong!");
            }
            return 1;
        }).exceptionally(ex -> {
            System.out.println("Exception: " + ex.getMessage());
            return 0;
        });

        // 獲取結果
        Integer result = future.get();
        System.out.println("Result: " + result);
    }
}

5. 組合多個 CompletableFuture

可以使用 thenCombine() 和 thenCompose() 方法來組合多個非同步任務：

thenCombine() 用於將兩個獨立的 CompletableFuture 結果結合起來。

package cn.juwatech.completablefuture;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

public class CombiningFutures {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> 2);
        CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> 3);

        CompletableFuture<Integer> combinedFuture = future1.thenCombine(future2, (result1, result2) -> result1 + result2);
        Integer combinedResult = combinedFuture.get();
        System.out.println("Combined Result: " + combinedResult);
    }
}

thenCompose() 用於鏈式呼叫，處理一個非同步任務的結果並返回另一個 CompletableFuture。

package cn.juwatech.completablefuture;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

public class ComposingFutures {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> 2)
                .thenCompose(result -> CompletableFuture.supplyAsync(() -> result * 2));

        Integer finalResult = future.get();
        System.out.println("Final Result: " + finalResult);
    }
}

6. 並行執行多個 CompletableFuture

使用 allOf() 和 anyOf() 方法可以並行執行多個非同步任務：

allOf() 等待所有 CompletableFuture 完成：

package cn.juwatech.completablefuture;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

public class AllOfExample {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        CompletableFuture<Void> future1 = CompletableFuture.runAsync(() -> {
            System.out.println("Task 1");
        });
        CompletableFuture<Void> future2 = CompletableFuture.runAsync(() -> {
            System.out.println("Task 2");
        });

        CompletableFuture<Void> allOfFuture = CompletableFuture.allOf(future1, future2);
        allOfFuture.get(); // 等待所有任務完成
        System.out.println("All tasks completed");
    }
}

anyOf() 等待任意一個 CompletableFuture 完成：

package cn.juwatech.completablefuture;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

public class AnyOfExample {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "Task 1 completed";
        });
        CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {
            return "Task 2 completed";
        });

        CompletableFuture<Object> anyOfFuture = CompletableFuture.anyOf(future1, future2);
        String result = (String) anyOfFuture.get();
        System.out.println(result);
    }
}

7. 總結

CompletableFuture 是處理非同步程式設計的強大工具，它不僅簡化了非同步任務的處理，還支援豐富的功能，如異常處理、任務組合和並行執行等。透過掌握這些技術，可以使得你的 Java 應用程式在處理非同步任務時更加高效和靈活。

本文著作權歸聚娃科技微賺淘客系統開發者團隊，轉載請註明出處！

Java中的非同步程式設計與CompletableFuture應用

相關文章