@Async註解詳解 以及 可能遇到的各種問題

 預設核心執行緒數：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();
    }
}