卧槽！你竟然连SpringBoot中的线程池都不会用。。。

左手的ㄟ右手 2022-10-15 15:53 33阅读 0赞

点击上方蓝色“java大数据修炼之道”, 选择“设为星标”

每晚九点: 技术干货 ???? 必定奉上

哈喽，各位新来的小伙伴们，大家好！由于公众号做了改版，为了保证公众号的资源能准时推送到你手里，大家记得将咱们的公众号 加星标置顶 ，在此真诚的表示感谢

来源：blog.csdn.net/m0\_37701381/article/details/81072774

## **\# 前言** ##

前两天做项目的时候，想提高一下插入表的性能优化，因为是两张表，先插旧的表，紧接着插新的表，一万多条数据就有点慢了

后面就想到了线程池ThreadPoolExecutor，而用的是Spring Boot项目，可以用Spring提供的对ThreadPoolExecutor封装的线程池ThreadPoolTaskExecutor，直接使用注解启用

## **\# 使用步骤** ##

先创建一个线程池的配置，让Spring Boot加载，用来定义如何创建一个ThreadPoolTaskExecutor，要使用@Configuration和@EnableAsync这两个注解，表示这是个配置类，并且是线程池的配置类

@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;
        }
    }

@Value是我配置在application.properties，可以参考配置，自由定义

# 异步线程配置
    # 配置核心线程数
    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-

创建一个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");
        }
    }

将Service层的服务异步化，在executeAsync()方法上增加注解@Async("asyncServiceExecutor")，asyncServiceExecutor方法是前面ExecutorConfig.java中的方法名，表明executeAsync方法进入的线程池是asyncServiceExecutor方法创建的。

接下来就是在Controller里或者是哪里通过注解@Autowired注入这个Service

@Autowired
    private AsyncService asyncService;
    
    
    @GetMapping("/async")
    public void async(){
        asyncService.executeAsync();
    }

用postmain或者其他工具来多次测试请求一下

2018-07-16 22:15:47.655  INFO 10516 --- [async-service-5] c.u.d.e.executor.impl.AsyncServiceImpl   : start executeAsync
    异步线程要做的事情
    可以在这里执行批量插入等耗时的事情
    2018-07-16 22:15:47.655  INFO 10516 --- [async-service-5] c.u.d.e.executor.impl.AsyncServiceImpl   : end executeAsync
    2018-07-16 22:15:47.770  INFO 10516 --- [async-service-1] c.u.d.e.executor.impl.AsyncServiceImpl   : start executeAsync
    异步线程要做的事情
    可以在这里执行批量插入等耗时的事情
    2018-07-16 22:15:47.770  INFO 10516 --- [async-service-1] c.u.d.e.executor.impl.AsyncServiceImpl   : end executeAsync
    2018-07-16 22:15:47.816  INFO 10516 --- [async-service-2] c.u.d.e.executor.impl.AsyncServiceImpl   : start executeAsync
    异步线程要做的事情
    可以在这里执行批量插入等耗时的事情
    2018-07-16 22:15:47.816  INFO 10516 --- [async-service-2] c.u.d.e.executor.impl.AsyncServiceImpl   : end executeAsync
    2018-07-16 22:15:48.833  INFO 10516 --- [async-service-3] c.u.d.e.executor.impl.AsyncServiceImpl   : start executeAsync
    异步线程要做的事情
    可以在这里执行批量插入等耗时的事情
    2018-07-16 22:15:48.834  INFO 10516 --- [async-service-3] c.u.d.e.executor.impl.AsyncServiceImpl   : end executeAsync
    2018-07-16 22:15:48.986  INFO 10516 --- [async-service-4] c.u.d.e.executor.impl.AsyncServiceImpl   : start executeAsync
    异步线程要做的事情
    可以在这里执行批量插入等耗时的事情
    2018-07-16 22:15:48.987  INFO 10516 --- [async-service-4] c.u.d.e.executor.impl.AsyncServiceImpl   : end executeAsync

[通过以上日志可以发现，\[async-service-\]是有多个线程的，显然已经在我们配置的线程池中执行了，并且每次请求中，controller的起始和结束日志都是连续打印的，表明每次请求都快速响应了，而耗时的操作都留给线程池中的线程去异步执行；][async-service-_controller]

虽然我们已经用上了线程池，但是还不清楚线程池当时的情况，有多少线程在执行，多少在队列中等待呢？这里我创建了一个ThreadPoolTaskExecutor的子类，在每次提交线程的时候都会将当前线程池的运行状况打印出来

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
     */
    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);
        }
    }

[如上所示，showThreadPoolInfo方法中将任务总数、已完成数、活跃线程数，队列大小都打印出来了，然后Override了父类的execute、submit等方法，在里面调用showThreadPoolInfo方法，这样每次有任务被提交到线程池的时候，都会将当前线程池的基本情况打印到日志中；][showThreadPoolInfo_Override_execute_submit_showThreadPoolInfo]

修改ExecutorConfig.java的asyncServiceExecutor方法，将ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor()改为ThreadPoolTaskExecutor executor = new VisiableThreadPoolTaskExecutor()

@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;
        }

再次启动该工程测试

2018-07-16 22:23:30.951  INFO 14088 --- [nio-8087-exec-2] u.d.e.e.i.VisiableThreadPoolTaskExecutor : async-service-, 2. do submit,taskCount [0], completedTaskCount [0], activeCount [0], queueSize [0]
    2018-07-16 22:23:30.952  INFO 14088 --- [async-service-1] c.u.d.e.executor.impl.AsyncServiceImpl   : start executeAsync
    异步线程要做的事情
    可以在这里执行批量插入等耗时的事情
    2018-07-16 22:23:30.953  INFO 14088 --- [async-service-1] c.u.d.e.executor.impl.AsyncServiceImpl   : end executeAsync
    2018-07-16 22:23:31.351  INFO 14088 --- [nio-8087-exec-3] u.d.e.e.i.VisiableThreadPoolTaskExecutor : async-service-, 2. do submit,taskCount [1], completedTaskCount [1], activeCount [0], queueSize [0]
    2018-07-16 22:23:31.353  INFO 14088 --- [async-service-2] c.u.d.e.executor.impl.AsyncServiceImpl   : start executeAsync
    异步线程要做的事情
    可以在这里执行批量插入等耗时的事情
    2018-07-16 22:23:31.353  INFO 14088 --- [async-service-2] c.u.d.e.executor.impl.AsyncServiceImpl   : end executeAsync
    2018-07-16 22:23:31.927  INFO 14088 --- [nio-8087-exec-5] u.d.e.e.i.VisiableThreadPoolTaskExecutor : async-service-, 2. do submit,taskCount [2], completedTaskCount [2], activeCount [0], queueSize [0]
    2018-07-16 22:23:31.929  INFO 14088 --- [async-service-3] c.u.d.e.executor.impl.AsyncServiceImpl   : start executeAsync
    异步线程要做的事情
    可以在这里执行批量插入等耗时的事情
    2018-07-16 22:23:31.930  INFO 14088 --- [async-service-3] c.u.d.e.executor.impl.AsyncServiceImpl   : end executeAsync
    2018-07-16 22:23:32.496  INFO 14088 --- [nio-8087-exec-7] u.d.e.e.i.VisiableThreadPoolTaskExecutor : async-service-, 2. do submit,taskCount [3], completedTaskCount [3], activeCount [0], queueSize [0]
    2018-07-16 22:23:32.498  INFO 14088 --- [async-service-4] c.u.d.e.executor.impl.AsyncServiceImpl   : start executeAsync
    异步线程要做的事情
    可以在这里执行批量插入等耗时的事情
    2018-07-16 22:23:32.499  INFO 14088 --- [async-service-4] c.u.d.e.executor.impl.AsyncServiceImpl   : end executeAsync

注意这一行日志：

2018-07-16 22:23:32.496  INFO 14088 --- [nio-8087-exec-7] u.d.e.e.i.VisiableThreadPoolTaskExecutor : async-service-, 2. do submit,taskCount [3], completedTaskCount [3], activeCount [0], queueSize [0]

这说明提交任务到线程池的时候，调用的是submit(Callable task)这个方法，当前已经提交了3个任务，完成了3个，当前有0个线程在处理任务，还剩0个任务在队列中等待，线程池的基本情况一路了然。

回复 【Java】获取java相关的视频教程和资料
    
    回复 【SpringCloud】获取SpringCloud相关多的学习资料
    回复 【PDF】获取2021java相关面试题教程
    回复 【加群】即可加入java学习交流研发部相关的技术交流群

*  [我的天! 8年开发，连登陆接口都写这么烂...][8_...]
 *  [颠覆认知 - MySQL数字类型如何选择？][- MySQL]
 *  [厉害了！把 HashMap 剖析的只剩渣了！][HashMap]
 *  [阿里一面：如何保障消息100%投递成功、消息幂等性？][100]
 *  [SpringBoot 中实现跨域的5种方式][SpringBoot _5]
 *  [60个相见恨晚的神器工具！][60]
 *  [超级全面的 SpringBoot 注解介绍，每一个用途都应该清晰][SpringBoot]

**看完本文有收获？请转发分享给更多人**

请长按二维码，关注 Java大数据修炼之道.

**推荐程序员必备公众号 **

**▼**

> **Java大数据修炼之道**
> 
> 公众号：
> 
> gh\_9119f24d3793
> 
> **推荐理由：**
> 
> 在这里，我们分享程序员相关技术，职场生活，行业热点资讯。不定期还会分享IT趣文和趣图。这里属于我们程序员自己的生活，工作和娱乐空间。
> 
>  ▼长按下方↓↓↓二维码识别关注
> 
> ####  ####
> 
> 关注 java大数据修炼之道
> 
>     每天学习java技术你想学的Java知识这里都有**![2df07be03d659c07abdb71a38dbd94a6.png][]**
> 
> ![bf3506f20005a26457c81ea4185ecb94.png][]

觉得对你有帮助，喜欢就"在看"呗^_^

喜欢就给个“**在看**”![61d632c6ec7af0b34414cbb87ff1006c.gif][]

[async-service-_controller]: http://mp.weixin.qq.com/s?__biz=MzIzMzgxOTQ5NA%3D%3D&chksm=e8fdc93bdf8a402d772682759acb3877f9110ba287710b2b1656dddb759996b02bf16d775135&idx=1&mid=2247537970&scene=21&sn=61f4edafbcec009384f806eebad2c569#wechat_redirect
[showThreadPoolInfo_Override_execute_submit_showThreadPoolInfo]: http://mp.weixin.qq.com/s?__biz=MzIzMzgxOTQ5NA%3D%3D&chksm=e8fdc972df8a40644751f4fc70704ba5091f60259a3db81283da65af180b4ddd59b133403e90&idx=2&mid=2247538043&scene=21&sn=4fdfeb2c38f96f4627f69c0005b577a6#wechat_redirect
[8_...]: http://mp.weixin.qq.com/s?__biz=MzU1NjczNTM5NQ%3D%3D&chksm=fbc20e56ccb587409979cdb0ce83d313e6fdb6350cad8a7f9f54cbd0d7968653e02e32e9b9db&idx=1&mid=2247499930&scene=21&sn=0f1bd961991baf56cc8d5d26e9ea6516#wechat_redirect
[- MySQL]: http://mp.weixin.qq.com/s?__biz=MzU1NjczNTM5NQ%3D%3D&chksm=fbc20e44ccb587527df9aa06b820dbed095f6e679cb1f809003ed0063c40b23296f0b743829b&idx=1&mid=2247499912&scene=21&sn=cea925f1929533c2041ca82a05380622#wechat_redirect
[HashMap]: http://mp.weixin.qq.com/s?__biz=MzU1NjczNTM5NQ%3D%3D&chksm=fbc233b5ccb5baa31a69115c7774c4313614c7ade3fb3dca7b4b8f6a4a7c658b4b9f1feb203b&idx=1&mid=2247499129&scene=21&sn=07a26e6b67b708ce1434527560fde28f#wechat_redirect
[100]: http://mp.weixin.qq.com/s?__biz=MzU1NjczNTM5NQ%3D%3D&chksm=fbc20ef1ccb587e78ffe7d5a0ae270224caf2aec60406a0482af5d656e55f36484866226f7a6&idx=1&mid=2247499837&scene=21&sn=aebe40b60bc265d2744900147358db94#wechat_redirect
[SpringBoot _5]: http://mp.weixin.qq.com/s?__biz=MzU1NjczNTM5NQ%3D%3D&chksm=fbc20ebeccb587a88d449715bcca92fef6dc56295fce2341332ba639564883691b484bdad8a2&idx=1&mid=2247499890&scene=21&sn=1e676d133912906324ba18e2495b7ec7#wechat_redirect
[60]: http://mp.weixin.qq.com/s?__biz=MzU1NjczNTM5NQ%3D%3D&chksm=fbc23173ccb5b865c4ebea5f45d09788a09c8d7c6cd9c02d15ef2c40b3ca2d0d16949e8ecb70&idx=1&mid=2247499711&scene=21&sn=b3dbd6429d4e28228f747b92b54dc301#wechat_redirect
[SpringBoot]: http://mp.weixin.qq.com/s?__biz=MzU1NjczNTM5NQ%3D%3D&chksm=fbc23087ccb5b9914f2788449140572f7e0f7c40eacc6d271fc46358590e2204b9fc17eef87e&idx=1&mid=2247499339&scene=21&sn=bc9651f8771a0fe22cb7a6c8fb99b5b5#wechat_redirect
[2df07be03d659c07abdb71a38dbd94a6.png]: /images/20221014/4b2c8314b4dd4e699d071f7efeeaceb4.png
[bf3506f20005a26457c81ea4185ecb94.png]: /images/20221014/39aa3a5f750346598eabf129302f0411.png
[61d632c6ec7af0b34414cbb87ff1006c.gif]: /images/20221014/bed6021b7125460586d79a0d6060ebb0.png