@ServletComponentScan
@SpringBootApplication
@EnableAsync
public class ClubApiApplication {
    public static void main(String[] args) {
        SpringApplication.run(ClubApiApplication.class, args);
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:task="http://www.springframework.org/schema/task"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                        http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task.xsd">
 
    <!-- 開啟異步，并引入線程池 -->
    <task:annotation-driven executor="threadPool" />
 
    <!-- 定義線程池 -->
    <bean id="threadPool"
        class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor">
        <!-- 核心線程數(shù)，默認為1 -->
        <property name="corePoolSize" value="10" />
 
        <!-- 最大線程數(shù)，默認為Integer.MAX_VALUE -->
        <property name="maxPoolSize" value="50" />
 
        <!-- 隊列最大長度，一般需要設置值>=notifyScheduledMainExecutor.maxNum；默認為Integer.MAX_VALUE -->
        <property name="queueCapacity" value="100" />
 
        <!-- 線程池維護線程所允許的空閑時間，默認為60s -->
        <property name="keepAliveSeconds" value="30" />
 
        <!-- 完成任務自動關閉 , 默認為false-->
        <property name="waitForTasksToCompleteOnShutdown" value="true" />
 
        <!-- 核心線程超時退出，默認為false -->
        <property name="allowCoreThreadTimeOut" value="true" />
 
        <!-- 線程池對拒絕任務（無線程可用）的處理策略，目前只支持AbortPolicy、CallerRunsPolicy；默認為后者 -->
        <property name="rejectedExecutionHandler">
            <!-- AbortPolicy:直接拋出java.util.concurrent.RejectedExecutionException異常 -->
            <!-- CallerRunsPolicy:主線程直接執(zhí)行該任務，執(zhí)行完之后嘗試添加下一個任務到線程池中，可以有效降低向線程池內(nèi)添加任務的速度 -->
            <!-- DiscardOldestPolicy:拋棄舊的任務、暫不支持；會導致被丟棄的任務無法再次被執(zhí)行 -->
            <!-- DiscardPolicy:拋棄當前任務、暫不支持；會導致被丟棄的任務無法再次被執(zhí)行 -->
            <bean class="java.util.concurrent.ThreadPoolExecutor$CallerRunsPolicy" />
        </property>
    </bean>
</beans>

<!--如果不使用自定義線程池，可以直接使用下面這段標簽-->
<!-- 
<task:executor id="WhifExecutor" pool-size="10"/> 
-->
<import resource="threadPool.xml" />
<task:annotation-driven executor="WhifExecutor" />

@Service
public class TranTest2Service {
    // 發(fā)送提醒短信 1
    @Async
    public void sendMessage1() throws InterruptedException {
        System.out.println("發(fā)送短信方法---- 1   執(zhí)行開始");
        Thread.sleep(5000); // 模擬耗時
        System.out.println("發(fā)送短信方法---- 1   執(zhí)行結(jié)束");
    }
 
    // 發(fā)送提醒短信 2
    @Async
    public void sendMessage2() throws InterruptedException {
        System.out.println("發(fā)送短信方法---- 2   執(zhí)行開始");
        Thread.sleep(2000); // 模擬耗時
        System.out.println("發(fā)送短信方法---- 2   執(zhí)行結(jié)束");
    }
}

@Service
public class OrderTaskServic {
    @Autowired
    private TranTest2Service tranTest2Service;
 
    // 訂單處理任務
    public void orderTask() throws InterruptedException {
        this.cancelOrder(); // 取消訂單
        tranTest2Service.sendMessage1(); // 發(fā)短信的方法   1
        tranTest2Service.sendMessage2(); // 發(fā)短信的方法  2
    }
 
    // 取消訂單
    public void cancelOrder() throws InterruptedException {
        System.out.println("取消訂單的方法執(zhí)行------開始");
        System.out.println("取消訂單的方法執(zhí)行------結(jié)束 ");
    }
}

package com.boot.common.conf;
import java.util.concurrent.ThreadPoolExecutor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
 
/**
 * 線程池配置
 * @author zhh
 *
 */
@Configuration
@EnableAsync
public class ThreadPoolTaskConfig {
 
/** 
 *   默認情況下，在創(chuàng)建了線程池后，線程池中的線程數(shù)為0，當有任務來之后，就會創(chuàng)建一個線程去執(zhí)行任務，
 *    當線程池中的線程數(shù)目達到corePoolSize后，就會把到達的任務放到緩存隊列當中；
 *  當隊列滿了，就繼續(xù)創(chuàng)建線程，當線程數(shù)量大于等于maxPoolSize后，開始使用拒絕策略拒絕 
 */
 
    /** 核心線程數(shù)（默認線程數(shù)） */
    private static final int corePoolSize = 20;
    /** 最大線程數(shù) */
    private static final int maxPoolSize = 100;
    /** 允許線程空閑時間（單位：默認為秒） */
    private static final int keepAliveTime = 10;
    /** 緩沖隊列大小 */
    private static final int queueCapacity = 200;
    /** 線程池名前綴 */
    private static final String threadNamePrefix = "Async-Service-";
 
    @Bean("taskExecutor") // bean的名稱，默認為首字母小寫的方法名
    public ThreadPoolTaskExecutor taskExecutor(){
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(corePoolSize);   
        executor.setMaxPoolSize(maxPoolSize);
        executor.setQueueCapacity(queueCapacity);
        executor.setKeepAliveSeconds(keepAliveTime);
        executor.setThreadNamePrefix(threadNamePrefix);
 
        // 線程池對拒絕任務的處理策略
        // CallerRunsPolicy：由調(diào)用線程（提交任務的線程）處理該任務
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        // 初始化
        executor.initialize();
        return executor;
    }
}

package com.boot.test1.service;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
 
@Service
public class TranTest2Service {
    Logger log = LoggerFactory.getLogger(TranTest2Service.class);
 
    // 發(fā)送提醒短信 1
        @PostConstruct // 加上該注解項目啟動時就執(zhí)行一次該方法
    @Async("taskExecutor")
    public void sendMessage1() throws InterruptedException {
        log.info("發(fā)送短信方法---- 1   執(zhí)行開始");
        Thread.sleep(5000); // 模擬耗時
        log.info("發(fā)送短信方法---- 1   執(zhí)行結(jié)束");
    }
 
    // 發(fā)送提醒短信 2
        @PostConstruct // 加上該注解項目啟動時就執(zhí)行一次該方法
    @Async("taskExecutor")
    public void sendMessage2() throws InterruptedException {
 
        log.info("發(fā)送短信方法---- 2   執(zhí)行開始");
        Thread.sleep(2000); // 模擬耗時
        log.info("發(fā)送短信方法---- 2   執(zhí)行結(jié)束");
    }
}

@Service
public class OrderTaskServic {
    @Autowired
    private TranTest2Service tranTest2Service;
    // 訂單處理任務
    public void orderTask() throws InterruptedException {
 
        this.cancelOrder(); // 取消訂單
        tranTest2Service.sendMessage1(); // 發(fā)短信的方法   1
        tranTest2Service.sendMessage2(); // 發(fā)短信的方法  2
    }
 
    // 取消訂單
    public void cancelOrder() throws InterruptedException {
        System.out.println("取消訂單的方法執(zhí)行------開始");
        System.out.println("取消訂單的方法執(zhí)行------結(jié)束 ");
    }
}

private static final String threadNamePrefix = "Async-Service-"; // 線程池名前綴，說明我們自定義的線程池被使用了