关于项目中多个线程池的兼容以及创建, ExecutorService

一时失言乱红尘 2024-02-17 13:23 13阅读 0赞

> 业务场景：已有的项目中，已经有很多地方用到了线程池，并且当时只定义了一个线程池，但是我要在项目中重新引入定义一个新的线程池做我的业务使用，那么此时就会出现问题

#### 目录 ####

*  业务场景分析
 *  解决方案
 *  测试代码：
 *  测试结果图片
 *   *   *  图片1
         *  图2

## 业务场景分析 ##

查看项目中ExecutorService的引用处，有很多很多个  
![在这里插入图片描述][b597dd16a11a47da9ce1de2ebfea619f.png_pic_center]

如果，直接加入后，项目直接无法启动（注入失败）代码具体举例  
出现的原因解释：因为之前的写法都是使用的@Autowired注解，根据类型去匹配，发现有两个同类型不同名字的bean，并且只是都是对象接收（并非集合），所以注入失败  
![在这里插入图片描述][4cab6e1314ac4ad691b85b8b8fbd99eb.png_pic_center]

package com.lzq.learn.test.线程池兼容问题;
    
    import com.google.common.util.concurrent.ThreadFactoryBuilder;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    
    import java.util.concurrent.*;
    import java.util.concurrent.atomic.AtomicInteger;
    
    
    /**
     *
     * 线程池配置类
     *
     * @author LiuZhiQiang
     */
    @Configuration
    public class ThreadPoolConfig {
        
    
        private static final Integer MAX_THREAD = 20;
    
        // 已有的
        @Bean
        public ExecutorService buildThreadPool(){
        
            ThreadFactory threadFactory = new ThreadFactoryBuilder().setNameFormat("test-queue-thread-%d").build();
            return Executors.newFixedThreadPool(MAX_THREAD,threadFactory);
        }
    
        // 本次版本，新添加的
        @Bean("newTaskThreadPool")
        public ExecutorService newTaskThreadPool() {
        
            int corePoolSize = 10;
            int maxPoolSize = 20;
            int queueCapacity = 20;
            long keepAliveSeconds = 60;
            return new ThreadPoolExecutor(
                    corePoolSize,
                    maxPoolSize,
                    keepAliveSeconds,
                    TimeUnit.SECONDS,
                    new ArrayBlockingQueue<>(queueCapacity),
                    new ThreadFactory() {
        
                        private final AtomicInteger threadCount = new AtomicInteger(1);
                        @Override
                        public Thread newThread(Runnable r) {
        
                            Thread thread = new Thread(r);
                            thread.setName("newTaskThreadPool_" + threadCount.getAndIncrement());
                            return thread;
                        }
                    },
                    new ThreadPoolExecutor.CallerRunsPolicy()
            );
        }
    }

## 解决方案 ##

> 要想解决启动失败并且不改动原先代码的情况下，解决办法也很简单。就是在原先的@Bean下方添加@Primary注解，表示该bean的优先级较高，可以单独注入单个对象

如图：  
![在这里插入图片描述][4ccb8be15aaf47eb8a8d5e2d7f3e3184.png_pic_center]

## 测试代码： ##

package com.lzq.learn.test.线程池兼容问题;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.beans.factory.annotation.Qualifier;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    import java.util.List;
    import java.util.concurrent.ExecutorService;
    
    /**
     *
     * @author LiuZhiQiang
     */
    @RestController(value = "testPoolController")
    @RequestMapping("testPool")
    public class TestController {
        
    
        @Autowired
        private ExecutorService executorService1;
        @Autowired
        private ExecutorService executorService2;
        @Autowired
        private ExecutorService executorService3;
        @Autowired
        @Qualifier("newTaskThreadPool")
        private ExecutorService executorService7;
        @Autowired
        private List<ExecutorService> executorServiceList;
    
        @GetMapping
        public void testPool() {
        
            executorService7.execute(() -> {
        
                System.out.println("executorService7 当前线程池的名字是 ： " + Thread.currentThread().getName());
            });
            executorService1.execute(() -> {
        
                System.out.println("executorService1 当前线程池的名字是 ： " + Thread.currentThread().getName());
            });
            executorService2.execute(() -> {
        
                System.out.println("executorService2 当前线程池的名字是 ： " + Thread.currentThread().getName());
            });
            executorService3.execute(() -> {
        
                System.out.println("executorService3 当前线程池的名字是 ： " + Thread.currentThread().getName());
            });
            int index = 1;
            for (ExecutorService executorService : executorServiceList) {
        
                int finalIndex = index;
                executorService.execute(() -> {
        
                    System.out.println("executorServiceList["+ finalIndex +"]    当前线程池的名字是 ： " + Thread.currentThread().getName());
                });
                index++;
            }
        }
    }

## 测试结果图片 ##

#### 图片1 ####

![在这里插入图片描述][b066c519d5e74e80895a92d46c85a44c.png_pic_center]

此图为控制台打印结果，有图可知，我们可以根据bean的name来区分注入的是哪一个bean，IOC同时默认的注入的就是带有@Primary的老的bean，所以我们就无需去改动之前定义的地方，只增强我们的新的版本改动即可。

#### 图2 ####

![在这里插入图片描述][6f7f05b6c4064fec9d55d583615ec7c3.png_pic_center]

此截图是断点调试，可以发现，我们虽然声明注入了多个相同类型的bean，但是他们的地址也只有两个，这也侧面说明了我们@Bean的单例。并且注入List的时候，会把所有的定义的bean都注入进来

[b597dd16a11a47da9ce1de2ebfea619f.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/06/cc0fdd9c567a4cd2990e89f23f105bd2.png
[4cab6e1314ac4ad691b85b8b8fbd99eb.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/06/87518f85b31643bfbb5a4a99b1ccea41.png
[4ccb8be15aaf47eb8a8d5e2d7f3e3184.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/06/ae7b638594434080b0069aaa0f06a008.png
[b066c519d5e74e80895a92d46c85a44c.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/06/2edf98c079684e5ca3e2fc451c376187.png
[6f7f05b6c4064fec9d55d583615ec7c3.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/06/39d02dcba4eb43f4a8358747992b1b55.png