利用completablefuture异步执行并发任务，并堵塞，全部完成后获取返回结果。

╰半夏微凉° 2023-10-10 14:52 0阅读 0赞

代码很简单，简单来说也就是。先创建一个线程池类，然后再写一个并发任务执行就可以了。因为此并发任务是利用

qvVerifyAsyncPool线程池处理的。

核心为，

//定义线程返回结果
            List<CompletableFuture<String>> futures = new ArrayList<CompletableFuture<String>>();

然后执行多个并发，同时将任务返回结果添加到此结果集合中

CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
                    //任务
    
                    return 1;
                },qvVerifyAsyncPool);

添加并发任务结果

futures.add(future);

堵塞当所有的任务完成时返回结果

//阻塞等待结果返回
            CompletableFuture<Void> allFutures = CompletableFuture.allOf(futures.toArray(new CompletableFuture[futures.size()]));
            List<String> result = allFutures.thenApply(v -> futures.stream().map(CompletableFuture::join).collect(Collectors.toList())).join();

完整代码如下：

该线程池类代码如下：

@Configuration
    @EnableAsync
    public class AsyncConfiguration {
    
    
        /**
         * 报告线程池--整个报告
         * @return ThreadPoolTaskExecutor
         */
        @Bean(name = "qvVerifyAsyncPool")
        public ThreadPoolExecutor QvVerifyAsyncPool(){
            return new ThreadPoolExecutor(
                    //核心线程数
                    qvCorePoolSize,
                    //最大线程数
                    qvMaxPoolSize,
                    qvKeepAliveSeconds,
                    TimeUnit.SECONDS,
                    //队列大小
                    new LinkedBlockingDeque<Runnable>(qvQueueCapacity),
                    //定义线程名称
                    new ThreadFactory() {
                        private final AtomicInteger mThreadNum = new AtomicInteger(1);
                        @Override
                        public Thread newThread(Runnable r) {
                            return new Thread(r, "qvVerifyAsyncPool-" + mThreadNum.getAndIncrement());
                        }
                    },
                    //拒绝策略
                    new ThreadPoolExecutor.AbortPolicy()
            );
        }
    }

/**
         * 简单Java并行代码
         * @param
         */
        public List<Integer> simpleParallel(){
    
            List<CompletableFuture<Integer>> futures = new ArrayList<>();
            for (int i = 0; i <10 ; i++) {
                CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
                    System.out.println("有返回值的异步任务"+Thread.currentThread().getName());
                    try {
                        Thread.sleep(3000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
    
                    return 1;
                },qvVerifyAsyncPool);
    
                futures.add(future);
            }
    
            // 使用allOf方法来表示所有的并行任务
            CompletableFuture<Void> allFutures = CompletableFuture.allOf(
                    futures.toArray(new CompletableFuture[futures.size()]));
    
    
            // 下面的方法可以帮助我们获得所有子任务的处理结果
            CompletableFuture<List<Integer>> finalResults = allFutures.thenApply(v ->
                    futures.stream().map(CompletableFuture::join).collect(Collectors.toList())
            );
            List<Integer> resultList =  finalResults.join();
    
            System.out.println(resultList);
    
            return resultList;
        }