public class AsyncTaskExecutor {
    /**
     * 核心線程數(shù)
     */
    private static final int corePoolSize = 10;
    /**
     * 最大線程數(shù)
     */
    private static final int maxPoolSize = 30;
    /**
     * 空閑線程回收時間
     * 空閑線程是指：當(dāng)前線程池中超過了核心線程數(shù)之后，多余的空閑線程的數(shù)量
     */
    private static final int keepAliveTime = 100;
    /**
     * 任務(wù)隊列/阻塞隊列
     */
    private static final int blockingQueueSize = 99999;
    private static final ThreadPoolExecutor executorPool = new ThreadPoolExecutor(
            corePoolSize,
            maxPoolSize,
            keepAliveTime,
            TimeUnit.MILLISECONDS,
            new LinkedBlockingQueue<>(blockingQueueSize),
            new ThreadFactoryBuilder().setNameFormat("AsyncTaskThread" + "-%d").build(),
            new ThreadPoolExecutor.CallerRunsPolicy()
    );
    /**
     * 異步任務(wù)執(zhí)行
     *
     * @param task
     */
    public static void execute(Runnable task) {
        executorPool.execute(task);
    }
}

@Slf4j
public class CommonTask implements Runnable {
    /**
     * 模塊ID
     */
    private Long modelId;
    /**
     * 模塊名稱
     */
    private ModelEnum modelName;
    /**
     * 構(gòu)造方法
     *
     * @param modelId
     * @param modelName
     */
    public CommonTask(Long modelId, ModelEnum modelName) {
        this.modelId = modelId;
        this.modelName = modelName;
    }
    @Override
    public void run() {
        log.info("start to process common task!!!");
        if (modelId.intValue() == ModelEnum.Chinese.getCode()) {
            String name = ModelEnum.Chinese.getValue();
            log.info("modelID = {}  modelName = {}", modelId, name);
        } else {
            modelName = ModelEnum.forValue(modelId.intValue());
            log.info("modelID = {}  modelName = {}", modelId, modelName.getValue());
        }
    }
}

public enum ModelEnum {
    Chinese(1, "語文"),
    Math(2, "數(shù)學(xué)"),
    English(3, "數(shù)學(xué)");
    /**
     * code
     */
    private int code;
    /**
     * value
     */
    private String value;
    /**
     * 映射結(jié)果集
     */
    private static final Map<Integer, ModelEnum> VALUE_MAP;
    static {
        VALUE_MAP = new HashMap<>();
        for (ModelEnum modelEnum : ModelEnum.values()) {
            VALUE_MAP.put(modelEnum.code, modelEnum);
        }
    }
    ModelEnum(int code, String value) {
        this.code = code;
        this.value = value;
    }
    public int getCode() {
        return code;
    }
    public String getValue() {
        return value;
    }
    /**
     * 根據(jù)code獲取枚舉實例
     *
     * @param code
     * @return
     */
    public static ModelEnum forValue(int code) {
        return VALUE_MAP.get(code);
    }
}

            //步驟1：創(chuàng)建異步任務(wù)
            CommonTask task = new CommonTask(1L, ModelEnum.Chinese);
            //步驟2：調(diào)用線程池異步執(zhí)行任務(wù)
            AsyncTaskExecutor.execute(task);
            log.info("main thread over...");

@Slf4j
@Configuration
@EnableAsync
public class TaskExecutor {
    @Value("${async.executor.thread.core_pool_size}")
    private int corePoolSize;
    @Value("${async.executor.thread.max_pool_size}")
    private int maxPoolSize;
    @Value("${async.executor.thread.queue_capacity}")
    private int queueCapacity;
    @Value("${async.executor.thread.name.deal_task}")
    private String taskNamePrefix;
    /**
     * 構(gòu)建線程池 并將其聲明為Bean
     * 方式1：可以通過注入的方式使用此線程池
     * 方式2：可以在方法上使用@Async("asyncTaskExecutor")這種注解方式使用此線程池
     *
     * @return
     */
    @Bean(name = "asyncTaskExecutor")
    public Executor asyncTaskExecutor() {
        log.info("start asyncTaskExecutor...");
        ThreadPoolTaskExecutor threadPoolTaskExecutor = new ThreadPoolTaskExecutor();
        threadPoolTaskExecutor.setCorePoolSize(corePoolSize);
        threadPoolTaskExecutor.setMaxPoolSize(maxPoolSize);
        threadPoolTaskExecutor.setQueueCapacity(queueCapacity);
        threadPoolTaskExecutor.setThreadNamePrefix(taskNamePrefix);
        //拒絕策略：當(dāng)前線程數(shù)已經(jīng)達(dá)到最大線程數(shù)后，如何處理新任務(wù)
        //CallerRunsPolicy()不在新線程中執(zhí)行任務(wù)，而是返回調(diào)用者所在的線程來執(zhí)行
        threadPoolTaskExecutor.setRejectedExecutionHandler(
                new ThreadPoolExecutor.CallerRunsPolicy());
        threadPoolTaskExecutor.initialize();
        return threadPoolTaskExecutor;
    }
}

async:
  executor:
    thread:
      core_pool_size: 10
      max_pool_size: 10
      queue_capacity: 99999
      name:
        deal_task: DEAL-TASK-

@Slf4j
@Service
public class WorkServiceImpl implements WorkService {
    @Async("asyncTaskExecutor")
    public void doAsyncTask() throws InterruptedException {
        Thread.sleep(1000);
        log.info("do AsyncTask...");
    }
}

@Slf4j
@RunWith(SpringRunner.class)
@SpringBootTest
public class UserDaoTest {
    SqlSession sqlSession;
    @Resource
    private WorkService workService;
    @Resource
    private Executor asyncTaskExecutor;
    @Test
    public void test() {
        try {
            //方式1：在方法上使用@Async("asyncTaskExecutor")這種注解方式使用此線程池
            for (int i = 0; i < 5; i++) {
                workService.doAsyncTask();
            }
            log.info("main Thread over...");
            //方式2：通過注入的方式使用此線程池（方便）
            asyncTaskExecutor.execute(() -> {
                log.info("async task is running..");
            });
            Thread.sleep(5000);
        }catch (Exception e) {
            e.printStackTrace();
        }
    }
}