CompleteFuture is a class introduced in Java 8 to simplify asynchronous programming and multithreaded task processing. 1. It supports manual completion of Future, chain calls, combination of multiple asynchronous operations and unified exception handling; 2. Compared with Java 5 Future, it is more powerful, and can manually set results, chain operations, combine tasks and flexibly handle exceptions; 3. Use supplyAsync or runAsync to create asynchronous tasks and specify thread pools; 4. thenApply convert results, thenAccept consumption results, thenRun to perform subsequent operations; 5. thenCompose serial combination tasks, thenCombine parallel merge results; 6. Exceptional and handle methods handle exceptions and provide default values ??or unified logic.

CompleteFuture is a class introduced in Java 8 to more conveniently handle asynchronous programming and multithreaded tasks. Simply put, it is a manual Future that can be completed, supports chain calls, combines multiple asynchronous operations, and can handle exceptions.

What is Future?

Before talking about CompletableFuture, you need to understand Future first. It is an interface introduced in Java 5 to represent the result of an asynchronous calculation. You can submit a task to the thread pool, get a Future, and then use the get() method to get the result.

But Future has a problem: the functionality is too basic. for example:

• Cannot set the results manually
• Chain operation is not supported
• Difficult to combine results with multiple futures
• Exception handling is not flexible enough

CompletableFuture is designed to solve these problems.

Use CompletableFuture to do asynchronous tasks

You can create an asynchronous task that runs in the background and the main thread continues to perform other operations.

 CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
    // Simulation time-consuming operation try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    return "Hello from async";
});

The above code will execute tasks asynchronously in the thread pool. The default is ForkJoinPool.commonPool() , and you can also pass it into your own thread pool.

If you need to wait for the result, call:

 String result = future.get(); // Will block until the result is ready

Chain call: thenApply, thenAccept, thenRun

CompleteFuture supports chain calls, making the connection between asynchronous operations more natural.

ThenApply: Convert the result

 CompleteFuture<Integer> future = CompleteFuture.supplyAsync(() -> "Hello")
    .thenApply(s -> s.length());

What this means is to return the string "Hello" asynchronously, and then turn it into length 5.

ThenAccept: consumption result (no return)

 CompletableFuture<Void> future = CompletableFuture.supplyAsync(() -> "World")
    .thenAccept(System.out::println);

Print out World, but does not return the value.

ThenRun: execute subsequent actions (not caring about the previous results)

 CompletableFuture<Void> future = CompletableFuture.runAsync(() -> System.out.println("Task 1"))
    .thenRun(() -> System.out.println("Task 2"));

Combining multiple asynchronous tasks: thenCompose and thenCombine

thenCompose: Serial Composition

Suitable for taking the result of the previous task as input to the next task.

 CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> "123")
    .thenCompose(s -> CompletableFuture.supplyAsync(() -> Integer.parseInt(s)));

ThenCombine: combine two tasks in parallel and merge the results

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

future1.thenCombine(future2, (a, b) -> ab);

This way, the two asynchronous results can be added together.

Handling exceptions: exceptionally and handle

Asynchronous tasks may also cause errors, and CompleteFuture provides a way to handle exceptions.

Exceptionally: Provide a default value when an exception occurs

 CompleteFuture<Integer> future = CompleteFuture.supplyAsync(() -> {
    if (true) throw new RuntimeException("Oops");
    return 100;
}).exceptionally(ex -> {
    System.out.println("Error occurred: " ex.getMessage());
    return 0; // Default value});

handle: It will be executed regardless of whether it is an exception, and can be handled in a unified manner

 CompleteFuture<Integer> future = CompleteFuture.supplyAsync(() -> {
    return 100;
}).handle((result, ex) -> {
    if (ex != null) {
        System.out.println("Exception: " ex.getMessage());
        return 0;
    }
    return result * 2;
});

Summarize common methods

• Create an asynchronous task: supplyAsync / runAsync
• Conversion result: thenApply
• Consumption results: thenAccept
• Follow-up operation: thenRun
• Serial Combination: thenCompose
• Parallel combination: thenCombine
• Exception handling: exceptionally / handle

Basically that's it. CompleteFuture is powerful, but it may feel a bit complicated when you get started. It is recommended to start with simple tasks and gradually master chain calls and combination methods.

The above is the detailed content of What is CompletableFuture in Java?. For more information, please follow other related articles on the PHP Chinese website!