How to use CompletableFuture to ensure the order of batch interface requests and efficiently process the results?

Java concurrent programming: Use CompletableFuture to efficiently and orderly handle batch interface requests

High concurrent access to third-party interfaces can significantly improve data processing efficiency, but if the thread execution order is not controlled, the final result may not match the original data order, resulting in subsequent processing errors. This article introduces how to use Java's CompletableFuture to ensure the orderly processing of interface requests and results in a multi-threaded environment.

Problem: Use CompletableFuture.runAsync directly to make asynchronous calls. Due to the unpredictable order of thread execution, the returned result is inconsistent with the order of the original data list. CompletableFuture.allOf can only guarantee the completion of all tasks, and the order cannot be guaranteed.

Solution: Use CompletableFuture.supplyAsync , which returns the result. Store the return result of each asynchronous task in CompletableFuture<string></string> In the list, after all tasks are completed, the results are collected in the original order through stream().map(CompletableFuture::join).collect(Collectors.toList()) .

Improved code example:

 public static void main(String[] args) {
    List<string> dataList = new ArrayList(); // Original data list// ... Initialize dataList ...

    ExecutorService executorService = new ThreadPoolExecutor(
            10, // corePoolSize
            20, // maximumPoolSize
            60L, // keepAliveTime
            TimeUnit.SECONDS,
            new LinkedBlockingQueue(1024), // workQueue
            new ThreadPoolExecutor.CallerRunsPolicy() // handler
    );

    List <completablefuture> > futures = new ArrayList();
    for (String data : dataList) {
        futures.add(CompletableFuture.supplyAsync(() -> {
            logger.info("Processing data: {}", data);
            // Call third-party interface to process data
            // ... Interface call and result processing logic...
            return data " - Processed Result"; // Return processing result}, executorService));
    }

    CompletableFuture.allOf(futures.toArray(new CompletableFuture[0])).thenRun(() -> {
        List<string> results = futures.stream()
                .map(CompletableFuture::join)
                .collect(Collectors.toList());
        logger.info("All tasks completed. Results: {}", JSON.toJSONString(results));
        // Subsequent processing results}).thenRun(() -> executorService.shutdown());
}</string></completablefuture></string>

The improved code uses CompletableFuture.supplyAsync to return the results of each interface call and is stored in the futures list. CompletableFuture.allOf ensures that the results are processed after all tasks are completed. stream().map(CompletableFuture::join).collect(Collectors.toList()) ensures that the results are collected in the original order, thus solving the problem of concurrency in the order of the results. The code also uses a custom thread pool for better control over resource usage.

The above is the detailed content of How to use CompletableFuture to ensure the order of batch interface requests and efficiently process the results?. For more information, please follow other related articles on the PHP Chinese website!