java线程池实战应用步骤详解

public class AsyncTaskExecutor {
    /**
     * 核心线程数
     */
    private static final int corePoolSize = 10;
    /**
     * 最大线程数
     */
    private static final int maxPoolSize = 30;
    /**
     * 空闲线程回收时间
     * 空闲线程是指：当前线程池中超过了核心线程数之后，多余的空闲线程的数量
     */
    private static final int keepAliveTime = 100;
    /**
     * 任务队列/阻塞队列
     */
    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()
    );
    /**
     * 异步任务执行
     *
     * @param task
     */
    public static void execute(Runnable task) {
        executorPool.execute(task);
    }
}

@Slf4j
public class CommonTask implements Runnable {
    /**
     * 模块ID
     */
    private Long modelId;
    /**
     * 模块名称
     */
    private ModelEnum modelName;
    /**
     * 构造方法
     *
     * @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, "数学"),
    English(3, "数学");
    /**
     * code
     */
    private int code;
    /**
     * value
     */
    private String value;
    /**
     * 映射结果集
     */
    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;
    }
    /**
     * 根据code获取枚举实例
     *
     * @param code
     * @return
     */
    public static ModelEnum forValue(int code) {
        return VALUE_MAP.get(code);
    }
}

            //步骤1：创建异步任务
            CommonTask task = new CommonTask(1L, ModelEnum.Chinese);
            //步骤2：调用线程池异步执行任务
            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;
    /**
     * 构建线程池 并将其声明为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);
        //拒绝策略：当前线程数已经达到最大线程数后，如何处理新任务
        //CallerRunsPolicy()不在新线程中执行任务，而是返回调用者所在的线程来执行
        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();
        }
    }
}