How to use CompletableFuture's thenCompose and thenCombine functions for asynchronous merge operations in Java

In Java, we often encounter scenarios that require asynchronous operations. For this situation, Java 8 introduced the CompletableFuture class, which provides us with rich asynchronous programming tools to make asynchronous programming simpler and easier. Among them, thenCompose and thenCombine are two commonly used combined asynchronous operation methods in the CompletableFuture class.

1. The use of thenCompose

ThethenCompose method is used to convert a CompletableFuture instance into another CompletableFuture instance. Specifically, it receives a Function parameter that takes as input the result returned by the previous CompletableFuture and returns a new CompletableFuture object. Here is an example:

CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
    // 模拟计算耗时
    try {
        Thread.sleep(2000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    return 10;
});

CompletableFuture<Integer> result = future.thenCompose(value -> CompletableFuture.supplyAsync(() -> value * 2));

result.whenComplete((res, ex) -> {
    if (ex != null) {
        ex.printStackTrace();
    } else {
        System.out.println(res);
    }
});

In the above code, first we create a CompletableFuture instance, which will simulate the calculation time in another thread. Next, we use the thenCompose method to convert it into a new CompletableFuture instance, which multiplies the result returned by the previous CompletableFuture by 2. Finally, we use the whenComplete method to output results or error messages.

2. The use of thenCombine

ThethenCombine method is used to merge two CompletableFuture instances into one. Specifically, it receives another CompletableFuture instance and a BiFunction parameter that takes as input the results returned by the two CompletableFutures and returns a new CompletableFuture object. Here is an example:

CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
    // 模拟计算耗时
    try {
        Thread.sleep(2000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    return 10;
});

CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> {
    // 模拟计算耗时
    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    return 5;
});

CompletableFuture<Integer> result = future1.thenCombine(future2, (value1, value2) -> value1 + value2);

result.whenComplete((res, ex) -> {
    if (ex != null) {
        ex.printStackTrace();
    } else {
        System.out.println(res);
    }
});

In the above code, we created two CompletableFuture instances, which simulated the execution of two computing tasks respectively. Next, we use the thenCombine method to merge the two CompletableFuture instances into a new instance that adds the results returned by the first two CompletableFutures. Finally, we use the whenComplete method to output results or error messages.

3. Use thenCompose and thenCombine to implement complex asynchronous operations

We have already introduced the use of thenCompose and thenCombine methods, and they are both very useful asynchronous operation methods. In fact, we can also use them to implement more complex asynchronous operations, such as aggregation operations on multiple calculation results.

CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
    // 模拟计算耗时
    try {
        Thread.sleep(2000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    return 10;
});

CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> {
    // 模拟计算耗时
    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    return 5;
});

CompletableFuture<Integer> future3 = CompletableFuture.supplyAsync(() -> {
    // 模拟计算耗时
    try {
        Thread.sleep(3000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    return 20;
});

CompletableFuture<Void> combinedFuture = CompletableFuture.allOf(future1, future2, future3);

CompletableFuture<Integer> result = combinedFuture.thenCompose(
        voidResult -> CompletableFuture.supplyAsync(() -> {
            int sum = future1.join() + future2.join() + future3.join();
            return sum;
        }));

result.whenComplete((res, ex) -> {
    if (ex != null) {
        ex.printStackTrace();
    } else {
        System.out.println(res);
    }
});

In the above code, we created three CompletableFuture instances, each of which simulates the execution of a computing task and returns the corresponding results. Next, we use the CompletableFuture.allOf method to combine these three instances and create a new CompletableFuture instance. It should be noted here that the allOf method returns a CompletableFuture instance of Void type, and its return value is null.

Then, we use the thenCompose method to convert the above CompletableFuture instance that returns null into a new CompletableFuture instance, which adds the results returned by the previous three CompletableFutures. In the callback function of the thenCompose method, we use the join() method to obtain the result value of each CompletableFuture instance and perform corresponding calculations. Finally, we use the whenComplete method to output results or error messages.

In general, thenCompose and thenCombine are very useful methods in the CompletableFuture class. They can help us perform asynchronous operations more conveniently and improve the concurrency and execution efficiency of the program.

The above is the detailed content of How to use CompletableFuture's thenCompose and thenCombine functions for asynchronous merge operations in Java. For more information, please follow other related articles on the PHP Chinese website!