科研实验室网站建设网站做成app的软件

当我们在项目中遇到很多业务同时处理，如果是串行肯定是影响性能的，这时候就需要异步执行了，说道异步肯定就有很多方案了

方案一：

比如使用spring的异步注解，比如下面的代码,每个方法上面都是异步注解，当时这种方案很多不足点，首先就是他的显示创建线程无法实现线程复用，然后就是无法统一处理异常及任务是否执行完了

class void test(){test01();test02();test03();
}

方案二 使用线程池

CountDownLatch 使用

线程池可以实现线程复用肯定是异步执行的不二选择
使用CountDownLatch：您可以在每个任务完成时递减 CountDownLatch，然后主线程等待 CountDownLatch 的计数为零，以确定所有任务都已经完成。这需要一些额外的编程工作，但允许更灵活的控制

int numberOfTasks = 10;
ExecutorService executorService = Executors.newFixedThreadPool(5);
CountDownLatch countDownLatch = new CountDownLatch(numberOfTasks);for (int i = 0; i < numberOfTasks; i++) {executorService.submit(() -> {// 执行任务countDownLatch.countDown();});
}try {countDownLatch.await();System.out.println("所有任务已经执行完毕");
} catch (InterruptedException e) {System.err.println("等待被中断");
}
executorService.shutdown();

awaitTermination

使用awaitTermination方法：ExecutorService 接口提供了 awaitTermination 方法，该方法允许您等待一段时间来检查线程池中的任务是否已经执行完。例如：

ExecutorService executorService = Executors.newFixedThreadPool(5);
// 提交任务到线程池executorService.shutdown(); // 停止接受新任务
try {if (executorService.awaitTermination(10, TimeUnit.SECONDS)) {System.out.println("所有任务已经执行完毕");} else {System.out.println("等待超时，仍有任务未执行完");}
} catch (InterruptedException e) {System.err.println("awaitTermination被中断");
}

invokeAll

ExecutorService executorService = Executors.newFixedThreadPool(5);
List<Callable<Void>> tasks = new ArrayList<>();
// 添加任务到tasksList<Future<Void>> futures = executorService.invokeAll(tasks);
for (Future<Void> future : futures) {if (!future.isDone()) {System.out.println("仍有任务未执行完");break;}
}
executorService.shutdown();

方案三

既然使用了线程池能否再优化下呢使用java8 毕竟流行的异步编程CompletableFuture
比如：

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;public class CompletableFutureExample {public static void main(String[] args) {CompletableFuture<Void> future1 = CompletableFuture.runAsync(() -> {此处可以将任务结果存放在一个集合或者一个对象中// 执行任务1System.out.println("Task 1 is running...");});CompletableFuture<Void> future2 = CompletableFuture.runAsync(() -> {// 执行任务2此处可以将任务结果存放在一个集合或者一个对象中System.out.println("Task 2 is running...");});CompletableFuture<Void> future3 = CompletableFuture.runAsync(() -> {// 执行任务3此处可以将任务结果存放在一个集合或者一个对象中System.out.println("Task 3 is running...");});CompletableFuture<Void> allOf = CompletableFuture.allOf(future1, future2, future3);try {allOf.get(); // 等待所有任务完成System.out.println("All tasks are completed.");} catch (InterruptedException | ExecutionException e) {e.printStackTrace();}}
}

但是这种写法也不够优雅，因为每个异步任务都需要把结果存放出来 ，可以优化下

    private List<Object> asyncHandleTask(Map<String, TaskHandlerService> handleServiceMap, Map<String, TaskResultParserDTO> taskResultParserMap) {//提交任务List<CompletableFuture<List<Object>>> completableFutureList = handleServiceMap.entrySet().stream().map(entry -> CompletableFuture.supplyAsync(() -> entry.getValue().handle(taskResultParserMap.get(entry.getKey())), threadPoolTaskExecutor)).collect(Collectors.toList());//等待所有任务完成CompletableFuture<Void> allTaskFeatureList = CompletableFuture.allOf(completableFutureList.toArray(new CompletableFuture[0]));//等待所有任务完成或者CompletableFuture<Void>[] futures = new CompletableFuture[]{future1, future2, future3};CompletableFuture<Void> allOf = CompletableFuture.allOf(futures);   //等待所有任务完成或者CompletableFuture<Void> allTaskFeatureList = CompletableFuture.allOf(completableFutureList.toArray(new CompletableFuture[completableFutureList.size]));//获取所有任务的结果数据CompletableFuture<List<List<Object>>> listCompletableFuture = allTaskFeatureList.thenApply(v -> completableFutureList.stream().map(CompletableFuture::join).collect(Collectors.toList()));List<List<Object>> resultList;try {resultList = listCompletableFuture.get();} catch (InterruptedException | ExecutionException e) {log.error("处理任务结果数据失败，{}", ExceptionUtils.getStackTrace(e));throw new CustomException(TaskProcessStatusEnum.WAIT_PARSER_RESULT_FAIL);}//整合数据return resultList.stream().flatMap(Collection::stream).collect(Collectors.toList());}