java使用 @Async 注解 + 线程池异步处理数据- 主线程等待子线程返回处理数据

男娘i 2023-06-07 03:19 18阅读 0赞

1 在@SpringBootApplication启动类 添加注解@EnableAsync  
2 异步方法使用注解@Async ,返回值为void或者Future  
3 切记一点 ,异步方法和调用方法一定要\*\*\*\* 写在不同的类中 \*\*\*\*,如果写在一个类中,  
是没有效果的

package com.xy.pay.main.config;
    
    import org.springframework.beans.factory.annotation.Qualifier;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.context.annotation.Primary;
    import org.springframework.scheduling.annotation.EnableAsync;
    import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
    
    import java.util.concurrent.Executor;
    
    /** * 线程池 配置 * * @author YJX * @date 2019/10/12 15:17 */
    @Configuration
    @EnableAsync
    public class ExecutorConfig { 
        //@Autowired
        //private TraceableThreadFactory traceableThreadFactory;
    
    
        /** * 默认的线程池 * * @return */
        @Bean
        @Primary
        @Qualifier("defaultExecutor")
        public Executor defaultExecutor() { 
            ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
            executor.setCorePoolSize(5);/*核心线程数*/
            executor.setMaxPoolSize(10);/*最大线程数*/
            executor.setQueueCapacity(10000);/*队列大小*/
            executor.setKeepAliveSeconds(60);/* 某线程空闲超过1分钟，就回收该线程*/
            //executor.setAllowCoreThreadTimeOut(true); // KeepAliveSeconds 设置也作用于【核心线程数】
            executor.setThreadNamePrefix("defaultExecutor-");
            //executor.setThreadFactory(traceableThreadFactory);
            //executor.setAwaitTerminationSeconds(3);
            executor.setRejectedExecutionHandler(null);
            executor.setWaitForTasksToCompleteOnShutdown(true);
            executor.initialize();
            return executor;
        }
    
        /** * 线程池 * * @return */
        @Bean
        @Qualifier("executor")
        public Executor reconciliationExecutor() { 
            ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
            executor.setCorePoolSize(3);/*核心线程数*/
            executor.setMaxPoolSize(3);/*最大线程数*/
            executor.setQueueCapacity(10000);/*队列大小*/
            executor.setKeepAliveSeconds(60 * 3);/* 某线程空闲超过3分钟，就回收该线程*/
            executor.setAllowCoreThreadTimeOut(true);   // KeepAliveSeconds 设置也作用于【核心线程数】
            executor.setThreadNamePrefix("executor-");
            //executor.setThreadFactory(traceableThreadFactory);
            executor.setRejectedExecutionHandler(null);
            executor.setWaitForTasksToCompleteOnShutdown(true);
            //executor.setAwaitTerminationSeconds(3);
            executor.initialize();
            return executor;
        }
    
    }

@GetMapping("thread")
        public void store() { 
            long startTime = System.currentTimeMillis();
            ArrayList<Object> list = new ArrayList<>();
            try { 
                System.out.println("主线程开始");
                Future<String> r1 = asyncThread.doTask1();
                Future<String> r2 = asyncThread.doTask2();
    
                while (true) { 
                    System.out.println("主线程等待中");
                    if (r1.isDone() && r2.isDone()) { 
                        list.add(r1.get());
                        list.add(r2.get());
                        break;
                    } else { 
                        TimeUnit.SECONDS.sleep(1);
                    }
                }
            } catch (Exception e) { 
                e.printStackTrace();
            }
            long endTime = System.currentTimeMillis();
            System.out.println("总耗时 = " + (endTime - startTime));
            System.out.println("list = " + list);
    
        }

# 注意! #

@Async异步注解要单独写一个类, 不能写在调用者的类里面 , 否则是单线程执行

3 切记一点 ,异步方法和调用方法一定要\*\*\*\* 写在不同的类中 \*\*\*\*,如果写在一个类中,  
是没有效果的  
就是下面的代码不能和调用者写在同一个类里面

/* * Copyright 2019 Wicrenet, Inc. All rights reserved. */
    package com.xy.pay.main.controller;
    
    import org.springframework.scheduling.annotation.Async;
    import org.springframework.scheduling.annotation.AsyncResult;
    import org.springframework.stereotype.Component;
    
    import java.util.concurrent.Future;
    import java.util.concurrent.TimeUnit;
    
    /** * 【】 * * @author YJX * Created on 2019/10/12 15:08 */
    @Component
    public class AsyncThread { 
        @Async("executor")
        public Future<String> doTask1() { 
            System.out.println("线程1开始");
            long l = System.currentTimeMillis();
            try { 
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
            System.out.println("t1结束耗时 = " + (System.currentTimeMillis() - l));
            return new AsyncResult<>("d1");
        }
    
        @Async("executor")
        public Future<String> doTask2() { 
            System.out.println("线程2开始");
            long l = System.currentTimeMillis();
            try { 
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
            System.out.println("t2结束耗时 = " + (System.currentTimeMillis() - l));
            return new AsyncResult<>("d2");
        }
    }