spring boot 默认线程池bean springboot线程池yml配置

转载

charlesc 2024-07-24 11:55:33

文章标签 java spring 开发语言线程池 Async 文章分类 spring boot 后端开发

1.我们都知道spring只是为我们简单的处理线程池，每次用到线程总会new 一个新的线程，效率不高，所以我们需要自定义一个线程池。

2.自定义线程池有两种方法，第一种自定义线程池然后使用自己的自定义的，第二种重写spring默认的线程池，然后使用自己重写过的线程池

一：自定义线程池

1.1 修改application.yml
#线程池配置参数
 task:
   pool:
     corePoolSize: 5 #设置核心线程数
     maxPoolSize: 20  #设置最大线程数
     keepAliveSeconds: 300 #设置线程活跃时间（秒）
     queueCapacity: 50 #设置队列容量
 1.2 线程池配置属性类TaskThreadPoolConfig .javaimport org.springframework.boot.context.properties.ConfigurationProperties;
  
 /**
  * 线程池配置属性类
  */
 @ConfigurationProperties(prefix = "task.pool")@Component
 public class TaskThreadPoolConfig {
     private int corePoolSize;
  
     private int maxPoolSize;
  
     private int keepAliveSeconds;
  
     private int queueCapacity;
     ...getter and setter methods...
 }
 1.3  注意启动类上一定要开启线程异步支持@EnableAsync
 @EnableConfigurationProperties({TaskThreadPoolConfig.class} ) // 开启配置属性支持
 1.4 创建线程池 TaskExecutePool .java/**
  * 创建线程池配置类
  */
 @Configuration
 public class TaskExecutePool {
  
     @Autowired
     private TaskThreadPoolConfig config;
  
     /**
      * 1.这种形式的线程池配置是需要在使用的方法上面@Async("taskExecutor"),
      * 2.如果在使用的方法上面不加该注解那么spring就会使用默认的线程池
      * 3.所以如果加@Async注解但是不指定使用的线程池，又想自己定义线程池那么就可以重写spring默认的线程池
      * 4.所以第二个方法就是重写默认线程池
      * 注意：完全可以把线程池的参数写到配置文件中
      */
  
     @Bean
     public Executor taskExecutor() {
         ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
         //核心线程池大小
         executor.setCorePoolSize(config.getCorePoolSize());
         //最大线程数
         executor.setMaxPoolSize(config.getMaxPoolSize());
         //队列容量
         executor.setQueueCapacity(config.getQueueCapacity());
         //活跃时间
         executor.setKeepAliveSeconds(config.getKeepAliveSeconds());
         //线程名字前缀
         executor.setThreadNamePrefix("TaskExecutePool-");
  
         // setRejectedExecutionHandler：当pool已经达到max size的时候，如何处理新任务
         // CallerRunsPolicy：不在新线程中执行任务，而是由调用者所在的线程来执行
         executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
          // 等待所有任务结束后再关闭线程池
         executor.setWaitForTasksToCompleteOnShutdown(true);
         executor.initialize();
         return executor;
     }
 }
 1.5 测试方法 
 import io.swagger.annotations.Api;
 import io.swagger.annotations.ApiOperation;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RequestMethod;
 import org.springframework.web.bind.annotation.ResponseBody;
 import org.springframework.web.bind.annotation.RestController;
  
 /**
  * @author qijx
  */
 @Api(description = "测试控制类11111")
 @RestController
 @RequestMapping("/threadPoolController1")
 public class ThreadPoolController1 {
  
         @Autowired
         private ThreadPoolService1 threadPoolService;
  
  
         @ApiOperation(value = "测试方法")
         @ResponseBody
         @RequestMapping(value = "/test",method = RequestMethod.GET)
         public String threadPoolTest() {
             threadPoolService.executeAsync();
             return "hello word!";
         }
  
  
 }
 1.6 service测试方法 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.scheduling.annotation.Async;
 import org.springframework.stereotype.Service;
  
 /**
  * @author qijx
  * @date 2019-07-03 17:40
  */
  
 @Service
 public class ThreadPoolService1 {
     private static final Logger logger = LoggerFactory.getLogger(ThreadPoolService1.class);
  
     @Async("taskExecutor") //指定使用那个线程池配置，不然会使用spring默认的线程池
     public void executeAsync() {
         logger.info("start executeAsync");
         try {
             System.out.println("当前运行的线程名称：" + Thread.currentThread().getName());
             Thread.sleep(1000);
         } catch (Exception e) {
             e.printStackTrace();
         }
         logger.info("end executeAsync");
     }
  
  
  
 }
 二：配置默认的线程池2.1 第一种方式的那个线程池使用时候总要加注解@Async("taskExecutor")，而这种方式是重写spring默认线程池的方式，使用的时候只需要加@Async注解就可以，不用去声明线程池类。
2.2 这个和上面的TaskThreadPoolConfig类相同，这里不重复
2.3 NativeAsyncTaskExecutePool.java 装配线程池
**
  * 原生(Spring)异步任务线程池装配类，实现AsyncConfigurer重写他的两个方法，这样在使用默认的
  *  线程池的时候就会使用自己重写的
  */
 @Slf4j
 @Configuration
 public class NativeAsyncTaskExecutePool implements AsyncConfigurer{
  
  
     //注入配置类
     @Autowired
     TaskThreadPoolConfig config;
  
     @Override
     public Executor getAsyncExecutor() {
         ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
         //核心线程池大小
         executor.setCorePoolSize(config.getCorePoolSize());
         //最大线程数
         executor.setMaxPoolSize(config.getMaxPoolSize());
         //队列容量
         executor.setQueueCapacity(config.getQueueCapacity());
         //活跃时间
         executor.setKeepAliveSeconds(config.getKeepAliveSeconds());
         //线程名字前缀
         executor.setThreadNamePrefix("NativeAsyncTaskExecutePool-");
  
         // setRejectedExecutionHandler：当pool已经达到max size的时候，如何处理新任务
         // CallerRunsPolicy：不在新线程中执行任务，而是由调用者所在的线程来执行
         executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
         // 等待所有任务结束后再关闭线程池
         executor.setWaitForTasksToCompleteOnShutdown(true);
         executor.initialize();
         return executor;
     }
  
  
     /**
      *  异步任务中异常处理
      * @return
      */
     @Override
     public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
         return new AsyncUncaughtExceptionHandler() {
  
             @Override
             public void handleUncaughtException(Throwable arg0, Method arg1, Object... arg2) {
                 log.error("=========================="+arg0.getMessage()+"=======================", arg0);
                 log.error("exception method:"+arg1.getName());
             }
         };
     }
 }
 2.4 测试controller/**
  * @author qijx
  */
 @Api(description = "测试控制类22222")
 @RestController
 @RequestMapping("/threadPoolController2")
 public class ThreadPoolController2 {
         @Autowired
         private ThreadPoolService2 threadPoolService;
  
         @ApiOperation(value = "测试方法")
         @ResponseBody
         @RequestMapping(value = "/test",method = RequestMethod.GET)
         public String threadPoolTest() {
             threadPoolService.executeAsync();
             return "hello word!";
         }
 }
 2.5 测试service方法/**
  * @author qijx
  */
  
 @Service
 public class ThreadPoolService2 {
     private static final Logger logger = LoggerFactory.getLogger(ThreadPoolService2.class);
  
     /**
      * @Async该注解不需要在指定任何bean
      */
     @Async
     public void executeAsync() {
         logger.info("start executeAsync");
         try {
             System.out.println("当前运行的线程名称：" + Thread.currentThread().getName());
             Thread.sleep(1000);
         } catch (Exception e) {
             e.printStackTrace();
         }
         logger.info("end executeAsync");
     }

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。