springboot线程池

package com.haier.backservice.config;

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

import java.util.concurrent.ThreadPoolExecutor;

/**
 * @author 
 * @since 2023/11/14
 * 线程池配置
 **/
@Configuration
public class ThreadPoolConfig {
    /**
     * cpu核心数
     */
    private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
    /**
     * 线程池核心线程数
     */
    private static final int COUR_SIZE = CPU_COUNT * 2;
    /**
     * 线程池最大线程数
     */
    private static final int MAX_COUR_SIZE = CPU_COUNT * 4;
    /**
     * 配置一个bean，配置线程池。
     * @Bean("myThreadPoolTaskExecutor")中的myThreadPoolTaskExecutor是线程池的名称，如果不配置名称，那么默认的名称是方法名ThreadPoolTaskExecutor。
     * @return ThreadPoolTaskExecutor
     */
    @Bean("myThreadPoolTaskExecutor")
    public ThreadPoolTaskExecutor threadPoolTaskExecutor() {
        ThreadPoolTaskExecutor threadPoolTaskExecutor = new ThreadPoolTaskExecutor();
        // 设置核心线程数
        threadPoolTaskExecutor.setCorePoolSize(COUR_SIZE);
        // 配置最大线程数
        threadPoolTaskExecutor.setMaxPoolSize(MAX_COUR_SIZE);
        // 配置队列容量（这里设置成最大线程数的四倍）
        threadPoolTaskExecutor.setQueueCapacity(MAX_COUR_SIZE * 4);
        // 给线程池设置名称前缀
        threadPoolTaskExecutor.setThreadNamePrefix("back-thread-");
        // 设置任务的拒绝策略
        // AbortPolicy（默认）：当工作队列已满并且无法再添加新任务时，抛出RejectedExecutionException异常
        // CallerRunsPolicy:当工作队列已满并且无法再添加新任务时，由提交任务的线程来执行该任务。也就是说，任务将在提交线程的上下文中执行
        // DiscardOldestPolicy：当工作队列已满并且无法再添加新任务时，丢弃队列中最早的任务（即等待时间最长的任务），然后尝试重新提交新任务
        // DiscardPolicy：当工作队列已满并且无法再添加新任务时，直接丢弃新任务，不做任何处理
        // 如果需要自定义拒绝策略，可以实现RejectedExecutionHandler接口，并在创建ThreadPoolExecutor时将其传递给构造函数
        threadPoolTaskExecutor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        return threadPoolTaskExecutor;
    }
}

package com.haier.backservice.config;

import com.haier.backservice.common.Constant;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;

/**
 * @author 
 * @since 2023/11/14
 * 线程池的使用
 * Async 加到类上是该类下的所有方法都是异步的
 **/
@Component
@Async(value = "myThreadPoolTaskExecutor")
public class ThreadPoolConfigUse {
    /**
     * 1.在需要使用线程池的类中注入线程池
     * 2.在需要使用线程池的方法上加上@Async注解
     * 3.在启动类上加上@EnableAsync注解
     */
     @Resource
     private ThreadPoolTaskExecutor threadPoolTaskExecutor;

    /**
     * 1.在需要使用线程池的类中注入线程池
     */
    public void pointcut(){
        threadPoolTaskExecutor.execute(()->{
            System.out.println(Thread.currentThread().getName());
        });
     }
     @Async
     public void asyncTest(){
         System.out.println(Thread.currentThread().getName());
     }
}

package com.haier.backservice;

import lombok.extern.slf4j.Slf4j;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.scheduling.annotation.EnableAsync;

@SpringBootApplication
@Slf4j
@MapperScan("com.haier.backservice.system.mapper")
@EnableAsync
public class BackserviceApplication {

   public static void main(String[] args) {
      ConfigurableApplicationContext context = SpringApplication.run(BackserviceApplication.class, args);
      // 打印加载的bean
//    String[] beanDefinitionNames = context.getBeanDefinitionNames();
//    Arrays.stream(beanDefinitionNames).forEach(log::info);
   }

}