How to use CompletableFuture in Java to notify when all elements are processed

CompletableFuture in Java is a very powerful asynchronous programming tool. It can help us perform task delivery, processing, notification and other operations during asynchronous processing, greatly simplifying the difficulty of asynchronous programming. When using CompletableFuture for asynchronous processing, there is a scenario where it is necessary to notify after all elements are processed. This article will introduce how to use CompletableFuture in Java to implement this scenario.

First of all, you need to understand the basic concepts and usage of CompletableFuture. CompletableFuture is a new class in Java 8 that provides a way to process results when performing operations asynchronously. It allows us to combine multiple asynchronous operations into a more complex operation and wait for all asynchronous operations to complete before proceeding to the next step.

In the scenario of notifying when all elements are processed, we need to use the method of CompletableFuture: allOf. This method can combine multiple CompletableFuture objects together and return a new CompletableFuture object after waiting for the asynchronous tasks of all objects to be completed.

The basic steps for using the allOf method are as follows:

1. Create several CompletableFuture objects to process different elements.
2. Call the CompletableFuture.allOf method, pass in all CompletableFuture objects as parameters, and wait for all asynchronous tasks to be completed.
3. After all asynchronous tasks are completed, the allOf method will return a new CompletableFuture object, which can be used for next processing.

Below, we use an example to demonstrate how to use CompletableFuture to notify when all elements are processed according to the above steps.

First, we need to define a Task class to simulate the processing of asynchronous tasks. The sample code is as follows:

import java.util.concurrent.CompletableFuture;

public class Task {
    public CompletableFuture<String> process(String element) {
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
            // 模拟异步任务的处理过程
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return element.toUpperCase();
        });
        return future;
    }
}

In the above code, the Task class defines a process method to process each element and return a CompletableFuture object. In this method, we use the CompletableFuture.supplyAsync method to simulate the processing of an asynchronous task, convert the element to uppercase and return it. At the same time, in order to simulate the time-consuming process of an asynchronous task, we added a 1-second sleep to the task.

Next, we define a Main class and use it in combination with the Task class and CompletableFuture to notify when all elements are processed. The sample code is as follows:

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CompletableFuture;

public class Main {
    public static void main(String[] args) {
        List<String> elements = new ArrayList<>();
        elements.add("hello");
        elements.add("world");
        elements.add("java");

        Task task = new Task();
        List<CompletableFuture<String>> futures = new ArrayList<>();

        // 遍历每个元素，并将它们的处理结果封装成一个CompletableFuture对象
        for (String element : elements) {
            CompletableFuture<String> future = task.process(element);
            futures.add(future);
        }

        // 等待所有异步任务完成，将它们的处理结果打印出来
        CompletableFuture<Void> allFutures = CompletableFuture.allOf(futures.toArray(new CompletableFuture[futures.size()]));
        allFutures.thenRun(() -> {
            System.out.println("所有异步任务已完成：");

            for (CompletableFuture<String> future : futures) {
                try {
                    String result = future.get();
                    System.out.println(result);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });
    }
}

In the above code, we define a List to save all elements, then create a Task object, traverse each element, and encapsulate their processing results into a CompletableFuture object , save these objects into a List. Next, we use the CompletableFuture.allOf method to wait for all asynchronous tasks to be completed, and after all tasks are completed, print the processing results of all tasks through the CompletableFuture object returned by the allOf method.

When we run the above program, we can see the following output:

所有异步任务已完成：
HELLO
WORLD
JAVA

The running results of the above program show that all asynchronous tasks have been processed and each element has been converted to uppercase. . At the same time, we also successfully implemented the function of notifying when all elements are processed.

To summarize, the method of using CompletableFuture to notify when all elements are processed is:

1. Create several CompletableFuture objects to process different elements.
2. Call the CompletableFuture.allOf method, pass in all CompletableFuture objects as parameters, and wait for all asynchronous tasks to be completed.
3. After all asynchronous tasks are completed, the allOf method will return a new CompletableFuture object, which can be used for next processing.

In general, CompletableFuture is a very convenient asynchronous programming tool that can help us combine multiple asynchronous tasks together and notify when all tasks are completed. In actual development, we can better use CompletableFuture to improve code concurrency and execution efficiency based on the above implementation method and actual business scenarios.

The above is the detailed content of How to use CompletableFuture in Java to notify when all elements are processed. For more information, please follow other related articles on the PHP Chinese website!