CompletableFuture是Java 8引入的一個強大的異步編程工具，它實現(xiàn)了Future和CompletionStage接口，允許對異步操作進行鍊式處理、組合和異常管理。 1. 它通過runAsync()和supplyAsync()方法實現(xiàn)異步任務(wù)執(zhí)行；2. 使用thenApply、thenAccept和thenRun支持操作鍊式調(diào)用；3. thenCompose和thenCombine用於組合多個異步操作；4. exceptionally和handle方法提供異常處理機制；5. 推薦結(jié)合自定義線程池使用以避免阻塞公共線程池，並強調(diào)在生產(chǎn)代碼中必須包含錯誤處理邏輯。

Asynchronous programming is a must-have skill these days, especially when dealing with I/O-bound operations or trying to scale applications efficiently. In Java, one of the most powerful tools for handling async tasks is CompletableFuture . It gives you fine-grained control over asynchronous operations and makes chaining, combining, and error handling much easier than using raw threads or even Future .

What is CompletableFuture?

CompletableFuture was introduced in Java 8 as part of the java.util.concurrent package. It's an implementation of the Future interface that also implements the CompletionStage interface. This means it not only allows you to get the result of an asynchronous computation but also enables you to chain dependent actions, handle exceptions, and combine multiple futures.

Think of it like this: instead of waiting for a task to finish before moving on, you can define what should happen once it finishes — all without blocking your main thread.

Starting Simple: Running Async Tasks

The simplest use case is running a task asynchronously. You can do this using methods like runAsync() (for Runnable ) or supplyAsync() (for Supplier ).

 CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
    // Simulate long-running task
    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    }
    return "Hello from async";
});

This creates a task that runs in a separate thread (by default using ForkJoinPool.commonPool() , unless you specify another executor). You can later retrieve the result by calling future.get() .

A few things to note:

• If you're doing blocking I/O, consider supplying your own executor to avoid starving the common pool.
• Don't forget to handle interruptions properly.
• Use supplyAsync when you expect a return value; use runAsync if you don't.

Chaining Operations: thenApply, thenAccept, thenRun

Once you have a future, you often want to do something with its result. That's where chaining comes in.

Here are three commonly used methods:

• thenApply : transforms the result
• thenAccept : consumes the result (no return)
• thenRun : runs a task after completion (ignores result)

Example:

 CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> "Hello")
    .thenApply(s -> s.length())
    .thenApply(len -> len * 2);

This returns a CompletableFuture<Integer> that will eventually resolve to 10 .

Use cases:

• Transforming data between stages
• Logging intermediate results
• Triggering side effects based on outcome

Tip: Keep transformations simple in each stage. Complex logic inside a single thenApply can make debugging harder.

Combining Futures: thenCompose and thenCombine

Sometimes you need to run two related async operations in sequence or parallel.

• thenCompose is used when you want to chain futures sequentially (ie, result of first is input to second).
• thenCombine is for parallel execution where you want to combine the results afterward.

Example with thenCompose :

 CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> "Hello");
CompletableFuture<String> future2 = future1.thenCompose(s -> CompletableFuture.supplyAsync(() -> s " World"));

Example with thenCombine :

 CompletableFuture<Integer> futureA = CompletableFuture.supplyAsync(() -> 10);
CompletableFuture<Integer> futureB = CompletableFuture.supplyAsync(() -> 20);
CompletableFuture<Integer> combined = futureA.thenCombine(futureB, (a, b) -> ab);

These methods are useful when:

• You need to aggregate data from multiple services
• You want to avoid callback hell by flattening nested futures
• You're building pipelines that require both serial and parallel steps

Handling Errors Gracefully with exceptionally or handle

Unpredictable things happen in async code — network failures, timeouts, etc. So knowing how to recover or fallback is important.

You can use:

• exceptionally(Function<Throwable, ? extends T>) to provide a fallback value
• handle(BiFunction<T, Throwable, R>) for more granular control (you get both result and exception)

Example:

 CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
    if (Math.random() > 0.5) throw new RuntimeException("Oops!");
    return 100;
}).exceptionally(ex -> {
    System.out.println("Error occurred: " ex.getMessage());
    return 0; // fallback value
});

Some best practices:

• Always include error handling in production code
• Avoid silent failures — log errors at least
• Consider retry strategies or circuit breakers in critical paths

Wrapping Up

Using CompletableFuture effectively can simplify complex async workflows and improve application responsiveness. Start small — maybe just wrapping a slow database call or HTTP request. Then gradually explore chaining, combining, and advanced error handling.

It might seem overwhelming at first with so many methods ( allOf , anyOf , whenComplete , etc.), but once you understand the core patterns, it becomes second nature.

基本上就這些。

以上是使用Java完整的future進行異步任務(wù)的詳細內(nèi)容。更多資訊請關(guān)注PHP中文網(wǎng)其他相關(guān)文章！