默认核心线程数：8，
    
    最大线程数：Integet.MAX_VALUE，
    队列使用LinkedBlockingQueue，
    容量是：Integet.MAX_VALUE，
    空闲线程保留时间：60s，
    线程池拒绝策略：AbortPolicy。

/**
 * @author HWX
 */
@Configuration
@EnableAsync  
public class ThreadPoolTaskConfig {
/*
    默认情况下，在创建了线程池后，线程池中的线程数为0，当有任务来之后，就会创建一个线程去执行任务，
     当线程池中的线程数目达到corePoolSize后，就会把到达的任务放到缓存队列当中；
   当队列满了，就继续创建线程，当线程数量大于等于maxPoolSize后，开始使用拒绝策略拒绝
 */
 
 
    /** 允许线程空闲时间（单位：默认为秒） */  
    private static final int KEEP_ALIVE_TIME = 60;
    /** 缓冲队列大小 */  
    private static final int QUEUE_CAPACITY = 1000;
    /** 线程池名前缀 */  
    private static final String THREAD_NAME_PREFIX = "Async-Service-";
  
    @Bean("taskExecutor") // bean的名称，默认为首字母小写的方法名  
    public ThreadPoolTaskExecutor taskExecutor(){
        // 获取当前机器CPU核数
        int cpuProcessors = Runtime.getRuntime().availableProcessors();
        if (cpuProcessors == 0) {
            cpuProcessors = 4;
        }
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();  
        executor.setCorePoolSize(cpuProcessors);
        executor.setMaxPoolSize(cpuProcessors+1);
        executor.setQueueCapacity(QUEUE_CAPACITY);
        executor.setKeepAliveSeconds(KEEP_ALIVE_TIME);
        executor.setThreadNamePrefix(THREAD_NAME_PREFIX);
  
        // 线程池对拒绝任务的处理策略  
        // CallerRunsPolicy：由调用线程（提交任务的线程）处理该任务  
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());  
        // 初始化  
        executor.initialize();  
        return executor;  
    }  
}  

@Service  
public class TranTest2Service {  
    Logger log = LoggerFactory.getLogger(TranTest2Service.class);  
  
    // 发送提醒短信 1  
        @PostConstruct // 加上该注解项目启动时就执行一次该方法  
    @Async("taskExecutor")  
    public void sendMessage1() throws InterruptedException {  
        log.info("发送短信方法---- 1   执行开始");  
        Thread.sleep(5000); // 模拟耗时  
        log.info("发送短信方法---- 1   执行结束");  
    }  
  
    // 发送提醒短信 2  
        @PostConstruct // 加上该注解项目启动时就执行一次该方法  
    @Async("taskExecutor")  
    public void sendMessage2() throws InterruptedException {  
  
        log.info("发送短信方法---- 2   执行开始");  
        Thread.sleep(2000); // 模拟耗时  
        log.info("发送短信方法---- 2   执行结束");  
    }  
}  

@Async("MyExecutor")
public Future<Map<Long, List>> queryMap(List ids) {
    List<> result = businessService.queryMap(ids);
    ..............
    Map<Long, List> resultMap = Maps.newHashMap();
    ...
    return new AsyncResult<>(resultMap);
}

public Map<Long, List> asyncProcess(List<BindDeviceDO> bindDevices,List<BindStaffDO> bindStaffs, String dccId) {
        Map<Long, List> finalMap =null;
        // 返回值：
        Future<Map<Long, List>> asyncResult = MyService.queryMap(ids);
        try {
            finalMap = asyncResult.get();
        } catch (Exception e) {
            ...
        }
        return finalMap;
}

/**application.yml配置**/
# 自定义线程池参数（用以@Async使用，可选）
execution:
  pool:
    core-size: 3
    queue-capacity: 500
    max-size: 10
    keep-alive: 3
    thread-name-prefix: customize-th-
 
 
/**线程池配置类**/
@Configuration
public class ExecutorConfig {
    /**
     * 核心线程
     */
    @Value("${execution.pool.core-size}")
    private int corePoolSize;
    /**
     * 队列容量
     */
    @Value("${execution.pool.queue-capacity}")
    private int queueCapacity;
    /**
     * 最大线程
     */
    @Value("${execution.pool.max-size}")
    private int maxPoolSize;
    /**
     * 保持时间
     */
    @Value("${execution.pool.keep-alive}")
    private int keepAliveSeconds;
    /**
     * 名称前缀
     */
    @Value("${execution.pool.thread-name-prefix}")
    private String preFix;
    @Bean("MyExecutor")
    public Executor myExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(corePoolSize);
        executor.setMaxPoolSize(maxPoolSize);
        executor.setQueueCapacity(queueCapacity);
        executor.setKeepAliveSeconds(keepAliveSeconds);
        executor.setThreadNamePrefix(preFix);
        executor.setRejectedExecutionHandler( new ThreadPoolExecutor.AbortPolicy());
        executor.initialize();
        return executor;
    }
}

/**测试类A**/
@Service
public class TestServiceAImpl implements TestServiceA {
    @Async("MyExecutor")
    @Override
    public void testMethod1() {
        for (int i = 0; i < 10; i++) {
            final int index = i;
            System.out.println("A类方法一的 " + index + " 被执行,线程名:" + Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    @Async("MyExecutor")
    @Override
    public void testMethod2() {
        for (int i = 0; i < 10; i++) {
            final int index = i;
            System.out.println("A类方法二的 " + index + " 被执行,线程名:" + Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
/**测试类B**/
@Service
public class TestServiceBImpl implements TestServiceB {
    @Async("MyExecutor")
    @Override
    public void testMethod1() {
        for (int i = 0; i < 10; i++) {
            final int index = i;
            System.out.println("B类方法一的 " + index + " 被执行,线程名:" + Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    @Async("MyExecutor")
    @Override
    public void testMethod2() {
        for (int i = 0; i < 10; i++) {
            final int index = i;
            System.out.println("B类方法二的 " + index + " 被执行,线程名:" + Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

@RestController
public class TestController{
    @Autowired
    private TestServiceA testServiceA;
    @Autowired
    private TestServiceB testServiceB;
    /**
     * 测试线程01
     */
    @GetMapping(value = "/threadTest")
    public void threadTest01() {
        System.out.println("【线程一】" + "group:"+ Thread.currentThread().getThreadGroup() + "; id:" +Thread.currentThread().getId()+"; name:"+ Thread.currentThread().getName());
        testServiceA.testMethod1();
        testServiceA.testMethod2();
        testServiceB.testMethod1();
        testServiceB.testMethod2();
    }
}