How to use CompletableFuture for asynchronous programming and concurrency control in Java 9

How to use CompletableFuture to implement asynchronous programming and concurrency control in Java 9

Introduction:
With the increasing demand for high performance and high concurrency in modern applications, asynchronous programming and concurrency control have become Common problems in development. The CompletableFuture class introduced in Java 9 provides a powerful mechanism to handle asynchronous operations and provides a simple and elegant way to implement concurrency control. This article will introduce the basic concepts of CompletableFuture in Java 9 and provide some sample code to demonstrate how to use CompletableFuture to implement asynchronous programming and concurrency control.

1. Introduction to CompletableFuture

CompletableFuture is a supplement to the asynchronous programming mechanism introduced in Java 8. It is a class that implements the Future and CompletionStage interfaces. The Future interface is used to represent the result of an asynchronous task that may not be completed, while the CompletionStage interface is used to express a calculation that may be performed asynchronously (including triggering operations and returning results), as well as subsequent operations that may be triggered after the calculation is completed. The CompletableFuture class provides a simplified way to use these interfaces and provides more powerful capabilities for handling asynchronous operations.

2. Basic usage examples

1. Creating a CompletableFuture object

First, we need to create a CompletableFuture object to represent the result of asynchronous calculation. The CompletableFuture class provides a variety of static methods to create such objects, such as completedFuture, supplyAsync, etc. The following is a sample code:

CompletableFuture<String> future = CompletableFuture.completedFuture("Hello, CompletableFuture!");

In the above code, we use the completedFuture method to create a completed CompletableFuture object and pass it a string as the calculation result.

2. Trigger asynchronous calculation

Next, we need to trigger an asynchronous calculation and associate it with the CompletableFuture object created in the previous step. The CompletableFuture class provides two methods to achieve this, namely runAsync and supplyAsync. The former is used to perform an asynchronous operation that does not return a result, while the latter is used to perform an asynchronous operation that returns a result. The following is a sample code:

CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
    // 异步计算，返回一个整数结果
    return 42;
});

In the above code, we use the supplyAsync method to create an asynchronously executed calculation that will return an integer result.

3. Processing asynchronous calculation results

Once the asynchronous calculation is completed, we can process the calculated results by calling the method of the CompletableFuture object. The CompletableFuture class provides a variety of methods to process results, such as thenApply, thenAccept, etc. The following is a sample code:

CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
    // 异步计算，返回一个整数结果
    return 42;
});
future.thenApply(result -> {
    // 处理结果并返回一个新的结果
    return result * 2;
})
.thenAccept(result -> {
    // 处理最终结果
    System.out.println("Final result: " + result);
});

In the above code, we call the thenApply method to process the result after the asynchronous calculation is completed, and return a new result. Then, we called the thenAccept method to process the final result and print it out.

3. Concurrency control example

In addition to asynchronous programming, CompletableFuture also provides some methods to implement concurrency control. The most commonly used methods include: anyOf, allOf and join.

1. anyOf method

The anyOf method is used to wait for any one of multiple CompletableFutures to complete. It will return a new CompletableFuture object that evaluates to the result of the first completed CompletableFuture object. The following is a sample code:

CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
    // 异步计算1
    return 1;
});
CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> {
    // 异步计算2
    return 2;
});
CompletableFuture<Object> resultFuture = CompletableFuture.anyOf(future1, future2);
resultFuture.thenAccept(result -> {
    System.out.println("First result: " + result);
});

In the above code, we use the anyOf method to wait for either future1 or future2 to be calculated and print out the result.

2. allOf method

The allOf method is used to wait for all calculations in multiple CompletableFutures to be completed. It will return a new CompletableFuture object, which evaluates to a Void value (null). Here is a sample code:

CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
    // 异步计算1
    return 1;
});
CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> {
    // 异步计算2
    return 2;
});
CompletableFuture<Void> resultFuture = CompletableFuture.allOf(future1, future2);
resultFuture.thenRun(() -> {
    System.out.println("All calculations are completed.");
});

In the above code, we use the allOf method to wait for all calculations in future1 and future2 to complete and print out a completion message.

3. join method

The join method is used to wait for the calculation result of a CompletableFuture and return the result. If an exception occurs during calculation, an exception will be thrown. The following is a sample code:

CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
    // 异步计算，返回一个整数结果
    return 42;
});
int result = future.join();
System.out.println("Result: " + result);

In the above code, we use the join method to wait for the calculation of the future to be completed and obtain its result.

Summary:

This article introduces the basic concepts of CompletableFuture in Java 9 and gives some sample code to demonstrate how to use CompletableFuture to implement asynchronous programming and concurrency control. By using CompletableFuture, we can handle asynchronous operations in a simple and elegant way and achieve flexible control of concurrent calculations. I hope these examples will help you understand and use CompletableFuture.

The above is the detailed content of How to use CompletableFuture for asynchronous programming and concurrency control in Java 9. For more information, please follow other related articles on the PHP Chinese website!