SpringBoot异步多线程调用注解@Async使用和CountDownLatch配合使用案例

2021-10-13 18:01:30 阅读：231 来源： 互联网

标签：10000 SpringBoot 毫秒 tsak 耗时任务 Async 多线程成名

zhuan:https://blog.csdn.net/weixin_43168010/article/details/103512942

@Autowired
    private Test test;
    @Override
    public List<Integer> findByMonth() {
        List<Integer> list = new ArrayList<>();
        for (int i =1;i<=12;i++){
            int count= baseMapper.findByMonth(i);
            list.add(count);
        }
        CountDownLatch countDownLatch = new CountDownLatch(6);
        System.out.println("开始执行多线程任务1111111111:::"+System.currentTimeMillis());
        for (int i =0;i<=5;i++){
            test.doTaskThree(countDownLatch,i);
 
        }
        try {
            countDownLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("主线程继续执行222222222222222:::::"+Thread.currentThread().getName());
        return list;
 
 
 
 
 
 
 
 
@Component
public class Test {
    //注意这个多线程方法的类一定要加@Component注解，拿给spring容器管理
    @Async
    public void doTaskThree(CountDownLatch countDownLatch,int i) {
        long start = System.currentTimeMillis();
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        long end = System.currentTimeMillis();
        System.out.println("第00" + i + "完成任务，耗时：" + (end - start) + "毫秒，线成名为::" + Thread.currentThread().getName());
        countDownLatch.countDown();
    }
 
}

开始执行多线程任务1111111111:::1576198763725
第005完成任务，耗时：10000毫秒，线成名为::SimpleAsyncTaskExecutor-6
第004完成任务，耗时：10000毫秒，线成名为::SimpleAsyncTaskExecutor-5
第000完成任务，耗时：10000毫秒，线成名为::SimpleAsyncTaskExecutor-1
第003完成任务，耗时：10000毫秒，线成名为::SimpleAsyncTaskExecutor-4
第002完成任务，耗时：10000毫秒，线成名为::SimpleAsyncTaskExecutor-3
第001完成任务，耗时：10000毫秒，线成名为::SimpleAsyncTaskExecutor-2
主线程继续执行222222222222222:::::http-nio-8300-exec-1

@Bean("getTaskExector")
    public Executor executor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        int threadCount = Runtime.getRuntime().availableProcessors();
        executor.setCorePoolSize(threadCount);//核心池大小
        executor.setMaxPoolSize(threadCount);//最大线程数
        executor.setQueueCapacity(1000);//队列程度
        executor.setKeepAliveSeconds(1000);//线程空闲时间
        executor.setThreadNamePrefix("tsak-asyn");//线程前缀名称
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.AbortPolicy());//配置拒绝策略
        return executor;
    }

开始执行多线程任务1111111111:::1576200103134
第002完成任务，耗时：10000毫秒，线成名为::tsak-asyn3
第001完成任务，耗时：10000毫秒，线成名为::tsak-asyn2
第003完成任务，耗时：10000毫秒，线成名为::tsak-asyn4
第005完成任务，耗时：10000毫秒，线成名为::tsak-asyn6
第004完成任务，耗时：10000毫秒，线成名为::tsak-asyn5
第000完成任务，耗时：10000毫秒，线成名为::tsak-asyn1
主线程继续执行222222222222222:::::http-nio-8300-exec-3
 
开始执行多线程任务1111111111:::1576200126619
第003完成任务，耗时：10000毫秒，线成名为::tsak-asyn2
第004完成任务，耗时：10000毫秒，线成名为::tsak-asyn4
第001完成任务，耗时：10000毫秒，线成名为::tsak-asyn8
第000完成任务，耗时：10000毫秒，线成名为::tsak-asyn7
第005完成任务，耗时：10000毫秒，线成名为::tsak-asyn6
第002完成任务，耗时：10000毫秒，线成名为::tsak-asyn3
主线程继续执行222222222222222:::::http-nio-8300-exec-2
 
开始执行多线程任务1111111111:::1576200167044
第005完成任务，耗时：10001毫秒，线成名为::tsak-asyn7
第003完成任务，耗时：10001毫秒，线成名为::tsak-asyn4
第004完成任务，耗时：10001毫秒，线成名为::tsak-asyn8
第000完成任务，耗时：10001毫秒，线成名为::tsak-asyn5
第002完成任务，耗时：10001毫秒，线成名为::tsak-asyn2
第001完成任务，耗时：10001毫秒，线成名为::tsak-asyn1
主线程继续执行222222222222222:::::http-nio-8300-exec-1

///////////////////////

@Async("getTaskExector")
    public Future<String> doTaskThree(int i) {
        long start = System.currentTimeMillis();
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        long end = System.currentTimeMillis();
        System.out.println("第00" + i + "完成任务，耗时：" + (end - start) + "毫秒，线成名为::" + Thread.currentThread().getName());
        return new AsyncResult("SUCUESS");
    }
 
 
 
 
 
System.out.println("开始执行多线程任务1111111111:::"+System.currentTimeMillis());
        List<Future<String>> list1 = new ArrayList<>();
        for (int i =0;i<=5;i++){
            Future<String> stringFuture = test.doTaskThree(i);
            list1.add(stringFuture);
        }
        boolean flag = false;
        while (!flag){
            for (Future<String> future:list1){
                try {
                    String s = future.get();
                    if (s =="成功"){
                        flag = true;
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
        System.out.println("主线程继续执行222222222222222:::::"+Thread.currentThread().getName());

标签：10000,SpringBoot,毫秒,tsak,耗时,任务,Async,多线程,成名
来源： https://www.cnblogs.com/yunger/p/15403320.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9

SpringBoot异步多线程调用注解@Async使用和CountDownLatch配合使用案例