SpringBoot 项目中创建线程池

@Configuration

@EnableAsync

public   class   ExecutorConfig {

     private   static   final   Logger logger = LoggerFactory.getLogger(ExecutorConfig. class );

     @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.prefix}" )

     private   String namePrefix;

     @Bean (name =  "asyncServiceExecutor" )

     public   Executor asyncServiceExecutor() {

         logger.info( "start asyncServiceExecutor" );

         ThreadPoolTaskExecutor executor =  new   ThreadPoolTaskExecutor();

         //配置核心线程数

         executor.setCorePoolSize(corePoolSize);

         //配置最大线程数

         executor.setMaxPoolSize(maxPoolSize);

         //配置队列大小

         executor.setQueueCapacity(queueCapacity);

         //配置线程池中的线程的名称前缀

         executor.setThreadNamePrefix(namePrefix);

         // rejection-policy：当pool已经达到max size的时候，如何处理新任务

         // CALLER_RUNS：不在新线程中执行任务，而是有调用者所在的线程来执行

         executor.setRejectedExecutionHandler( new   ThreadPoolExecutor.CallerRunsPolicy());

         //执行初始化

         executor.initialize();

         return   executor;

     }

}

> 推荐下自己做的 Spring Cloud 的实战项目：

>

> <https: //github测试数据/YunaiV/onemall>

# 异步线程配置

# 配置核心线程数

async.executor.thread.core_pool_size =  5

# 配置最大线程数

async.executor.thread.max_pool_size =  5

# 配置队列大小

async.executor.thread.queue_capacity =  99999

# 配置线程池中的线程的名称前缀

async.executor.thread.name.prefix = async-service-

public   interface   AsyncService {

     /** * 执行异步任务 * 可以根据需求，自己加参数拟定，我这里就做个测试演示 */

     void   executeAsync();

}

@Service

public   class   AsyncServiceImpl  implements   AsyncService {

     private   static   final   Logger logger = LoggerFactory.getLogger(AsyncServiceImpl. class );

     @Override

     @Async ( "asyncServiceExecutor" )

     public   void   executeAsync() {

         logger.info( "start executeAsync" );

         System.out.println( "异步线程要做的事情" );

         System.out.println( "可以在这里执行批量插入等耗时的事情" );

         logger.info( "end executeAsync" );

     }

}

@Autowired

private   AsyncService asyncService;

@GetMapping ( "/async" )

public   void   async(){

     asyncService.executeAsync();

}

import   org.slf4j.Logger;

import   org.slf4j.LoggerFactory;

import   org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

import   org.springframework.util.concurrent.ListenableFuture;

import   java.util.concurrent.Callable;

import   java.util.concurrent.Future;

import   java.util.concurrent.ThreadPoolExecutor;

/** * @Author: ChenBin * @Date: 2018/7/16/0016 22:19 */

public   class   VisiableThreadPoolTaskExecutor  extends   ThreadPoolTaskExecutor {

     private   static   final   Logger logger = LoggerFactory.getLogger(VisiableThreadPoolTaskExecutor. class );

     private   void   showThreadPoolInfo(String prefix) {

         ThreadPoolExecutor threadPoolExecutor = getThreadPoolExecutor();

         if   ( null   == threadPoolExecutor) {

             return ;

         }

         logger.info( "{}, {},taskCount [{}], completedTaskCount [{}], activeCount [{}], queueSize [{}]" ,

                 this .getThreadNamePrefix(),

                 prefix,

                 threadPoolExecutor.getTaskCount(),

                 threadPoolExecutor.getCompletedTaskCount(),

                 threadPoolExecutor.getActiveCount(),

                 threadPoolExecutor.getQueue().size());

     }

     @Override

     public   void   execute(Runnable task) {

         showThreadPoolInfo( "1. do execute" );

         super .execute(task);

     }

     @Override

     public   void   execute(Runnable task,  long   startTimeout) {

         showThreadPoolInfo( "2. do execute" );

         super .execute(task, startTimeout);

     }

     @Override

     public   Future<?> submit(Runnable task) {

         showThreadPoolInfo( "1. do submit" );

         return   super .submit(task);

     }

     @Override

     public   <T> Future<T> submit(Callable<T> task) {

         showThreadPoolInfo( "2. do submit" );

         return   super .submit(task);

     }

     @Override

     public   ListenableFuture<?> submitListenable(Runnable task) {

         showThreadPoolInfo( "1. do submitListenable" );

         return   super .submitListenable(task);

     }

     @Override

     public   <T> ListenableFuture<T> submitListenable(Callable<T> task) {

         showThreadPoolInfo( "2. do submitListenable" );

         return   super .submitListenable(task);

     }

}

@Bean (name =  "asyncServiceExecutor" )

     public   Executor asyncServiceExecutor() {

         logger.info( "start asyncServiceExecutor" );

         //在这里修改

         ThreadPoolTaskExecutor executor =  new   VisiableThreadPoolTaskExecutor();

         //配置核心线程数

         executor.setCorePoolSize(corePoolSize);

         //配置最大线程数

         executor.setMaxPoolSize(maxPoolSize);

         //配置队列大小

         executor.setQueueCapacity(queueCapacity);

         //配置线程池中的线程的名称前缀

         executor.setThreadNamePrefix(namePrefix);

         // rejection-policy：当pool已经达到max size的时候，如何处理新任务

         // CALLER_RUNS：不在新线程中执行任务，而是有调用者所在的线程来执行

         executor.setRejectedExecutionHandler( new   ThreadPoolExecutor.CallerRunsPolicy());

         //执行初始化

         executor.initialize();

         return   executor;

     }