多线程/异步线程 ThreadPoolTaskExecutor

ThreadPoolTaskExecutor 线程池

	ThreadPoolTaskExecutor 线程池是springboot默认的线程池，它的本质还是ThreadPoolExecutor,
springboot对其进行了进一步的封装。

1.为什么需要自己创建ThreadPoolTaskExecutor线程池

	既然springboot已经有默认的ThreadPoolTaskExecutor线程池了，那我们在项目中为什么还需要自己重新创建一
个新的新的线程池? 这就需要我们了解线程池的几个参数：
	1.corePoolSize（核心线程数）：线程池中的核心线程数量，即使线程池处于空闲状态，这些核心线程也不会被
	销毁。
	2.maximumPoolSize（最大线程数）：线程池允许创建的最大线程数量。如果阻塞队列满了，并且已创建的线程
	数小于最大线程数，则线程池会再创建新的线程执行任务。
	3.keepAliveTime（非核心线程的空闲时间）：非核心线程等待keepAliveTime时间后还没有获取到任务就会自动
	销毁。
	4.queueCapacity（任务队列）：用于保存等待执行的任务的阻塞队列。
	5.RejectedExecutionHandler（拒绝策略）：当线程池中的线程达到maximumPoolSize，且workQueue同时达到
	最大值，此时仍然有任务提交过来，那么必须采取一种策略处理提交的新任务。

其中corePoolSize参数，springboot默认是1，只创建一个异步线程，不够用；且maximumPoolSize
和queueCapacity参数默认是最大值，这样可能会引起OOM异常。所以在项目中使用异步线程时，最
好自己手动定义线程池。

2.自定义线程池

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

import java.util.concurrent.ThreadPoolExecutor;

/**
 * 自定义线程池
 * @Configuration 定义为配置类让spring容器读取
 * @EnableAsync 启动异步线程(这个注解可以放在这里，也可以放在项目启动器上；这2个地方有一个添加就行)
 */
@Configuration
@EnableAsync
public class ExecutorConfig {

    /**
     * 核心线程数
     */
    private static final int corePoolSize = 10;
    /**
     * 最大线程数
     */
    private static final int maxPoolSize = 20;
    /**
     * 队列容量
     */
    private static final int que = 1000;
    /**
     * 线程没有使用时，最大保持时间-秒
     */
    private static final int keepAlive = 600;

    private static final String preName = "Async-Task-";

    @Bean(name = "asyncTaskExecutor")
    public ThreadPoolTaskExecutor asyncTaskExecutor() {

        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        //核心线程数
        executor.setCorePoolSize(corePoolSize);
        //最大线程数
        executor.setMaxPoolSize(maxPoolSize);
        //队列最大长度
        executor.setQueueCapacity(que);
        //线程无任务时允许的空闲保持的时间（秒）
        executor.setKeepAliveSeconds(keepAlive);
        //线程名称前缀
        executor.setThreadNamePrefix(preName);
        //线程拒绝策略：缓存队列满了之后直接抛弃
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.AbortPolicy());
        executor.initialize();

        return executor;
    }

}

3.使用

直接在需要的方法上添加注解就行

	/**	成功案例
     * 如果项目中定义了多个线程池，需要指定使用哪一个
     * 	@Async("asyncTaskExecutor") 和上面线程池的@Bean(name = "asyncTaskExecutor") 一致
     */
    @Async
    public void a () {

        log.info("项目1: " + Thread.currentThread().getName());
    }
    
	@Async("asyncTaskExecutor")
    public void b () {
        log.info("项目2: " + Thread.currentThread().getName());

    }
/** 打印执行结果
 * 2024-08-09 18:25:33.015  INFO 23320 --- [ce-Async-Task-1] com.service.impl.OrderServiceImpl    : 项目1: Interface-Async-Task-1
 * 2024-08-09 18:25:35.013  INFO 23320 --- [ce-Async-Task-2] com.service.impl.OrderServiceImpl    : 项目2: Interface-Async-Task-2
 * 2024-08-09 18:25:36.009  INFO 23320 --- [ce-Async-Task-3] com.service.impl.OrderServiceImpl    : 项目1: Interface-Async-Task-3
 */

//失败案例
    public void save() {
        log.info("主线程: " + Thread.currentThread().getName());
        a();
        b();
    }

    @Async
    public void a () {

        log.info("项目1: " + Thread.currentThread().getName());
    }

    @Async("asyncTaskExecutor")
    public void b () {
        log.info("项目2: " + Thread.currentThread().getName());

    }
   /**
     * 2024-08-09 18:30:10.493  INFO 20360 --- [io-20030-exec-1] com.service.impl.OrderServiceImpl    : 主线程: http-nio-20030-exec-1
     * 2024-08-09 18:30:10.494  INFO 20360 --- [io-20030-exec-1] com.service.impl.OrderServiceImpl    : 项目1: http-nio-20030-exec-1
     * 2024-08-09 18:30:10.494  INFO 20360 --- [io-20030-exec-1] com.service.impl.OrderServiceImpl    : 项目2: http-nio-20030-exec-1
     */

4.注意事项

1.@Async 注解的方法必须是 public 的，否则不会被 Spring AOP 代理捕获，导致异步执行不生效。
2.不能使用new关键字来创建实例，调用实例中被@Async注解的方法。因为实例没有没spring AOP代理，
不在spring
容器中。需要使用依赖注入的方式。
3.调用者和被调用者不能在同一个类中。当调用 @Async 注解的方法的类和被调用的方法在同一个类中时，
@Async 注解不会生效。因为 Spring 的 AOP 代理是基于接口的，对于同一个类中的方法调用，不会经过代理，
因此 @Async 注解不会被处理。
4.一个方法如果同时被@Async 和@Transactional注解，可能会导致事务失效或不可预测的问题。