线程池使用

作用(优点)

1. 降低资源消耗
   1. 通过重复利用已创建的线程降低线程创建和销毁造成的消耗。
2. 提高响应速度
   1. 当任务到达时，任务可以不需要等到线程创建就能立即执行。
3. 提高线程的可管理性
   1. 线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。

缺点

1. 适用于生存周期较短的的任务，不适用于又长又大的任务。
2. 不能对于线程池中任务设置优先级。
3. 不能标识线程的各个状态，比如启动线程，终止线程。
4. 对于任意给定的应用程序域，只能允许一个线程池与之对应。
5. 线程池所有线程都处于多线程单元中，如果想把线程放到单线程单元中，线程池就废掉了。

SpringBoot使用线程池

// 核心线程数量，默认1
corePoolSize
// 最大线程数量，默认Integer.MAX_VALUE
maxPoolSize
// 空闲线程存活时间
keepAliveSeconds
// 线程阻塞队列容量,默认Integer.MAX_VALUE
queueCapacity
// 是否允许核心线程超时
allowCoreThreadTimeOut

1. 配置一个线程池

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.Executor;
import java.util.concurrent.ThreadPoolExecutor;

/**
 * @Author: 
 * @Date: Created in 2021/09/10 09:40
 * @Description： 线程池配置
 */
@EnableAsync    // 启用 Spring 的异步方法执行功能
@Configuration
public class ExecutorConfig {


    // new ThreadPoolTaskExecutor();
    /**
     * 核心线程数量，默认1
     */
    private int corePoolSize = 3;

    /**
     * 最大线程数量，默认Integer.MAX_VALUE;
     */
    private int maxPoolSize = 5;

    /**
     * 空闲线程存活时间
     */
    private int keepAliveSeconds = 60;

    /**
     * 线程阻塞队列容量,默认Integer.MAX_VALUE
     */
    private int queueCapacity = 1;

    /**
     * 是否允许核心线程超时
     */
    private boolean allowCoreThreadTimeOut = false;




    @Bean("asyncExecutor")
    public Executor asyncExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        // 配置核心线程数量
        executor.setCorePoolSize(corePoolSize);
        // 配置最大线程数
        executor.setMaxPoolSize(maxPoolSize);
        // 配置队列容量
        executor.setQueueCapacity(queueCapacity);
        // 配置空闲线程存活时间
        executor.setKeepAliveSeconds(keepAliveSeconds);

        executor.setAllowCoreThreadTimeOut(allowCoreThreadTimeOut);

        // 设置拒绝策略，直接在execute方法的调用线程中运行被拒绝的任务
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());

        // 执行初始化
        executor.initialize();
        return executor;
    }
}

2. 创建Service接口，执行异步任务

@Service
@Slf4j
public class AsyncService {

    @Async("asyncExecutor")
    public void executeAsync(){
        int id = new Random().nextInt(100);

        log.info("{} start",id);
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        log.info("{} end",id);
    }
}

3. 编写Controller

@RestController
public class AsyncController {

    @Autowired
    private AsyncService asyncService;

    @GetMapping("/async")
    public void async(){
        asyncService.executeAsync();
    }
}