Location>code7788 >text

Do you really understand CompleteFuture? I advise you to use it with caution in the project

Popularity：982 ℃/2025-03-23 16:36:22

1. Preface

In actual projects, we often use multi-threaded and asynchronous to help us do something.

For example, when a user draws a prize, he will send him a push asynchronously.

For example, a period of unrelated business logic was originally executed sequentially, and time-consuming = (A + B + C). Now, multi-threading is used to speed up execution speed, and time-consuming = Max(A, B, C).

Many times, for convenience, we use it directlyCompletableFutureLet's deal with it, but it's really a lot of pitfalls, let's talk about it in detail one by one.

2. CompleteFuture principle

2.1 CompletableFuture API

There are several ways to submit tasks in CompleteFuture

public static CompletableFuture<Void> runAsync(Runnable runnable) 
public static CompletableFuture<Void> runAsync(Runnable runnable, Executor executor) 
public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier) 
public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier, Executor executor)

These four methods are used to submit tasks. The difference is that the task submitted by supplyAsync has a return value, while the task submitted by runAsync has no return value. Both interfaces have an overloaded method, and the second entry parameter is the specified thread pool. If not specified, the () thread pool is used by default.

2.2 ForkJoinPool

The Fork/Join framework is aParallel computing framework, , is designed to improve the execution speed of tasks with recursive properties. A typical task is to gradually break the problem into smaller tasks until each subtask is simple enough to solve directly, and then aggregate the results.

The Fork/Join framework is based on the "work Stealing Algorithm" algorithm. The core idea of ​​this algorithm is that each worker has its own task queue (double-ended queue,Deque). When a thread completes the tasks in its own queue, it will steal the execution of tasks in other threads, so that CPU resources will not be wasted because a thread is waiting.

The Fork/Join framework is ideal for these workloads:

  • Recursive tasks: Such as Fibonacci sequence, merge sorting and equal division and conquer algorithm.
  • Large-scale data processing: Quickly perform parallel operations on sets, arrays, etc.
  • Image processing: Tasks with large data volumes such as image processing can be divided into multiple small tasks and processed in parallel.

That is to say, ForkJoinPoolMore suitable for CPU-intensive, but not for IO-intensive. However, most of our business are IO-intensive, such as waiting for the return of the database, waiting for the return of the downstream RPC, waiting for the return of the sub-method, etc.

2.3 Application of ForkJoinPool in CompletableFuture

Let’s talk about the conclusion first:

  1. If you are usingCompletableFutureIf there is no specified thread pool, the default one will be used.ForkJoinPool

  2. The basis for whether CompletableFuture uses the default thread pool is related to the number of CPU cores of the machine. The default thread pool will be used only when the number of CPU cores -1 is greater than 1, otherwise it will be used for each CompleteFuture taskCreate a new thread to execute。

  3. If your CPU core number is 4 cores, then at most, there is only one3 core threads(3 threads, are you sure it's enough?)

3. CompletableFuture pit

3.1 The ForkJoinPool thread is not enough and is in a waiting state

In order to speed up the running of the code, Xiao Ming changed the original A+B+C running logic into (A, B, C) running logic, and used 3CompletableFutureTo execute, the time to shorten from the original 900ms to 300ms. The simple code is as follows:

public void test1() {
    a();
    b();
    c();
}

public void test2() {
    CompletableFuture<Integer> f1 = (() -> a());
    CompletableFuture<Integer> f2 = (() -> b());
    CompletableFuture<Integer> f3 = (() -> c());
}

After going online, Xiao Ming was in a good mood and was waiting for a promotion and salary increase. Unexpectedly, he encountered an online alarm the next day. The interface frequently exceeded the timeout, which was slower than before, and some reached 10s+. Xiao Ming really couldn't figure it out.

Later, the investigation found that there were a lot of use in the projectwhereEach machine has 8 cores, that is, 7 threads, which is not enough, so a lot of them are waiting for threads to pass through., so the time-consuming process is getting worse and worse, and an avalanche eventually formed, and the interface directly timed out infinitely.

answer:useCompletableFutureThe thread pool isolation must be achieved, and the default one cannot be used.ForkJoinPoolThread pool

3.2 Is CompletableFuture slower?

Xiao Ming learned to be smart after this incident and usedCompletableFutureWrite a thread pool by yourself. A few days later, another alarm was released on the line, and a large number of interfaces were timed out, and Xiao Ming was stunned again. Xiao Ming's code is as follows:

ExecutorService es = (5);
public void test1() {
    (a(1), es);
    (b(1), es);
    (c(1), es);
}

Later, the troubleshooting found that the default thread pool of springmvc tomcat is 200, while your thread pool is only 5, which means that when the interface requests to climb.

For example, there are 200 requests coming now. When executing test1, if you do not use the thread pool, there will be no problem. However, when using the thread pool, 5 thread pools are not enough. Waiting for the thread to be released will slower and slower, and eventually drag down the entire service.

3.3 CompleteFuture deadlock?

Xiao Ming said I will never use it againCompletableFuture, Xiao Ming said I will directly increase the thread pool to 200, and that will definitely be fine. Readers will think about whether it is feasible. The answer is absolutely not feasible. The core thread is set so large that it consumes a lot of CPU, so it must be set within a reasonable range.

Let’s look at the deadlock issue again. It’s not Xiao Ming’s fault. This time it’s Xiaohong’s turn. The following is the code for the deadlock:

ExecutorService es = (5);
public void test() {
    for (int i = 0; i < 5; i++) {
       (() -> a(), es); 
    }
}

public void a() {
    CompletableFuture<Integer> f = (() -> 1, es);
    try {
       ();
    } catch (Exception e) {}
}

It's not a good place to stay here. Since there are 5 threads, in the test method, use all 5 threads, and then test calls sub-method a. becauseSharedIn the same thread pool es, method a will never get the thread pool, method a will never be executed successfully, and then the test method will never be executed successfully, and then it will be a thread that will always block deadlock.

Therefore, the solution is to try not to use the same thread pool for different businesses, and customize your own thread pool for your business, instead of sharing a commonPool for convenience.

4. Last

By the aboveCompletableFutureI believe you are correct in the analysis and some actual cases of trappingCompletableFutureI have a better understanding of the usage.

Finally, I want to explain one thing, in the business code,If you can use multi-threading, you won't use multi-threading, because it brings far more side effects than the benefits it brings, unless you are very clear about the principle.

CompletableFutureDo you really understand? Welcome to leave a message in the comment area for discussion.

<Previous Next>