springboot线程池创建

public class HttpApiThreadPool {
 /** 获取当前系统的CPU 数目*/
 static int cpuNums = Runtime.getRuntime().availableProcessors();
 /** 线程池核心池的大小*/
 private static int corePoolSize = 10;
 /** 线程池的最大线程数*/
 private static int maximumPoolSize = cpuNums * 5; 
 public static ExecutorService httpApiThreadPool = null; 
 
 /**
  * 静态方法
  */
 static{
  System.out.println("创建线程数:"+corePoolSize+",最大线程数:"+maximumPoolSize);
  //建立10个核心线程，线程请求个数超过20，则进入队列等待
  httpApiThreadPool = new ThreadPoolExecutor(corePoolSize, maximumPoolSize, 0L,
  TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(100),new ThreadFactoryBuilder().setNameFormat("PROS-%d").build());
 } 
}

 public static void main(String[] args) {
  HttpApiThreadPool.httpApiThreadPool.execute(()->System.out.println("测试"));
 }

@Configuration
public class TreadPoolConfig {
 private Logger logger = LoggerFactory.getLogger(TreadPoolConfig.class);
 /** 获取当前系统的CPU 数目*/
 int cpuNums = Runtime.getRuntime().availableProcessors();
 /** 线程池核心池的大小*/
 private  int corePoolSize = 10;
 /** 线程池的最大线程数*/
 private  int maximumPoolSize = cpuNums * 5;
 
    /**
     * 消费队列线程
     * @return
     */
    @Bean(value = "httpApiThreadPool")
    public ExecutorService buildHttpApiThreadPool(){
     logger.info("TreadPoolConfig创建线程数:"+corePoolSize+",最大线程数:"+maximumPoolSize);
        ExecutorService pool = new ThreadPoolExecutor(corePoolSize, maximumPoolSize, 0L,
 TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(100),new ThreadFactoryBuilder().setNameFormat("PROS-%d").build()); 
        return pool ;
 } 
}

   //注入
    @Resource
 private TreadPoolConfig treadPoolConfig;
   //调用 
   public void test() {
  treadPoolConfig.buildHttpApiThreadPool().execute(()->System.out.println("tre"));
 }

import lombok.Data;
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;
@Data
@Configuration
@EnableAsync //开启异步请求
public class ThreadPoolConfig {
  
    private static final int corePoolSize = 10;   // 核心线程数（默认线程数）
    private static final int maxPoolSize = 100;   // 最大线程数
    private static final int keepAliveTime = 10;  // 允许线程空闲时间（单位：默认为秒）
    private static final int queueCapacity = 500; // 缓冲队列数
    /**
     * 默认异步线程池
     * @return
     */
    @Bean("taskExecutor")
    public ThreadPoolTaskExecutor taskExecutor(){
        ThreadPoolTaskExecutor pool = new ThreadPoolTaskExecutor();
        pool.setThreadNamePrefix("--------------全局线程池-----------------");
        pool.setCorePoolSize(corePoolSize);
        pool.setMaxPoolSize(maxPoolSize);
        pool.setKeepAliveSeconds(keepAliveTime);
        pool.setQueueCapacity(queueCapacity);
        // 直接在execute方法的调用线程中运行
        pool.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        // 初始化
        pool.initialize();
        return pool;
    }
}

@Async("taskExecutor")