前言

前两篇文章，我们已经学会了如何使用spring boot的多线程和自定义线程池。这篇文章，我们要深入了解上一篇文章中线程池的配置具体含义。

准备工作

说明

为了方便观察线程的情况（如执行完毕数量，正在执行数量，队列中等待数量等），我们应该先写一个可以将线程情况打印到控制台的类。

下面将介绍一种方式，在每次调用线程的时候，都会将当前线程的情况打印到控制台。

项目结构

└── Study├── pom.xml├── src│   ├── main│   │   ├── java│   │   │   └── top│   │   │       └── yxdz│   │   │           └── study│   │   │               └── spring│   │   │                   └── springboot│   │   │                       ├── thread│   │   │                       │   └── service│   │   │                       │       ├── ITestService.java│   │   │                       │       └── impl│   │   │                       │           └── TestSerivceImpl.java│   │   │                       └── utils│   │   │                           ├── SysThreadValueConfig.java│   │   │                           └── config│   │   │                               └── Thread│   │   │                                   ├── SysThreadConfig.java│   │   │                                   └── VisiableThreadPoolTaskExecutor.java│   │   └── resources│   │       ├── application.yml│   └── test│       └── java│           └── top│               └── yxdz│                   └── study│                       └── StudyApplicationTests.java

关键代码

• VisiableThreadPoolTaskExecutor.java

  继承ThreadPoolTaskExecutor，自定义展示线程方法printThreadPoolInfo，在每个继承方法执行前调用，实现每次调用线程都会打印当前线程池情况的日志。

  package top.yxdz.study.spring.springboot.utils.config.Thread;import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  import org.springframework.context.annotation.Configuration;
  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;/*** 实现每次调用都打印线程池情况*/
  @Configuration
  public class VisiableThreadPoolTaskExecutor extends ThreadPoolTaskExecutor {private static final Logger LOG = LoggerFactory.getLogger(VisiableThreadPoolTaskExecutor.class);/*** 打印线程池信息** @param functionName 调用函数*/private void printThreadPoolInfo(String functionName){try {ThreadPoolExecutor threadPoolExecutor = getThreadPoolExecutor();LOG.info("{}, {}, taskCount[{}], completedTaskCount [{}], activeCount [{}], queueSize [{}]",this.getThreadNamePrefix(), functionName, threadPoolExecutor.getTaskCount(),threadPoolExecutor.getCompletedTaskCount(), threadPoolExecutor.getActiveCount(),threadPoolExecutor.getQueue().size());}catch (IllegalStateException e){LOG.error("ThreadPoolTaskExecutor not initialized");}}@Overridepublic void execute(Runnable task){printThreadPoolInfo("1.execute");super.execute(task);}@Overridepublic void execute(Runnable task, long startTimeout){printThreadPoolInfo("2.execute");super.execute(task, startTimeout);}@Overridepublic Future<?> submit(Runnable task){printThreadPoolInfo("1.submit");return super.submit(task);}@Overridepublic <T> Future<T> submit(Callable<T> task){printThreadPoolInfo("2.submit");return super.submit(task);}@Overridepublic ListenableFuture<?> submitListenable(Runnable task){printThreadPoolInfo("1.submitListenable");return super.submitListenable(task);}@Overridepublic <T> ListenableFuture<T> submitListenable(Callable<T> task){printThreadPoolInfo("2.submitListenable");return super.submitListenable(task);}@Overrideprotected void cancelRemainingTask(Runnable task){printThreadPoolInfo("1.cancelRemainingTask");super.cancelRemainingTask(task);}
  }

• SysThreadConfig.java

  在自定义线程池中，实例化上面自定义的继承类VisiableThreadPoolTaskExecutor即可。

  package top.yxdz.study.spring.springboot.utils.config.Thread;import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  import org.springframework.beans.factory.annotation.Autowired;
  import org.springframework.context.annotation.Bean;
  import org.springframework.context.annotation.Configuration;
  import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
  import top.yxdz.study.spring.springboot.utils.SysThreadValueConfig;import java.util.concurrent.Executor;
  import java.util.concurrent.ThreadPoolExecutor;/*** 自定义线程池*/
  @Configuration
  public class SelfThreadConfig {private static Logger LOG = LoggerFactory.getLogger(SelfThreadConfig.class);@AutowiredSysThreadValueConfig sysValueConfig;@Beanpublic Executor myThreadPool(){//实例化继承类VisiableThreadPoolTaskExecutor，实现每次调用线程会打印线程汇总情况日志ThreadPoolTaskExecutor executor = new VisiableThreadPoolTaskExecutor();//核心线程池大小executor.setCorePoolSize(sysValueConfig.getCorePoolSize());//最大线程数executor.setMaxPoolSize(sysValueConfig.getMaxPoolSize());//队列容量executor.setQueueCapacity(sysValueConfig.getQueueCapacity());//活跃时间executor.setKeepAliveSeconds(sysValueConfig.getKeepAliveSeconds());//线程名字前缀executor.setThreadNamePrefix("my-thread-pool");//线程池满的时候，处理新任务的策略//CALLER_RUNS：不在新线程中执行任务，而是由调用者所在的线程来执行executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());//线程实例化executor.initialize();return executor;}
  }

执行结果

······
2018-12-19 19:22:46.065  INFO 65471 --- [           main] s.s.u.c.T.VisiableThreadPoolTaskExecutor : my-thread-pool, 2.submit, taskCount[0], completedTaskCount [0], activeCount [0], queueSize [0]
2018-12-19 19:22:46.066  INFO 65471 --- [           main] s.s.u.c.T.VisiableThreadPoolTaskExecutor : my-thread-pool, 2.submit, taskCount[1], completedTaskCount [0], activeCount [1], queueSize [0]
······

配置参数详解

线程池运行规则

下图是从其他博客(Springboot学习笔记（一）-线程池的简化及使用)转载过来。看的懂更好，看不懂也没关系，下面会进行详细说明。

自定义配置样例代码

package top.yxdz.study.spring.springboot.utils.config.Thread;import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import top.yxdz.study.spring.springboot.utils.SysThreadValueConfig;import java.util.concurrent.Executor;
import java.util.concurrent.ThreadPoolExecutor;/*** 自定义线程池*/
@Configuration
public class SelfThreadConfig {private static Logger LOG = LoggerFactory.getLogger(SelfThreadConfig.class);@AutowiredSysThreadValueConfig sysValueConfig;@Beanpublic Executor myThreadPool(){//实例化继承类VisiableThreadPoolTaskExecutor，实现每次调用线程会打印线程汇总情况日志ThreadPoolTaskExecutor executor = new VisiableThreadPoolTaskExecutor();//核心线程池大小executor.setCorePoolSize(sysValueConfig.getCorePoolSize());//最大线程数executor.setMaxPoolSize(sysValueConfig.getMaxPoolSize());//队列容量executor.setQueueCapacity(sysValueConfig.getQueueCapacity());//活跃时间executor.setKeepAliveSeconds(sysValueConfig.getKeepAliveSeconds());//线程名字前缀executor.setThreadNamePrefix("my-thread-pool");//线程池满的时候，处理新任务的策略//CALLER_RUNS：不在新线程中执行任务，而是由调用者所在的线程来执行executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());//线程实例化executor.initialize();return executor;}
}

参数定义

• CorePoolSize(核心线程池数)

  线程池创建时候初始化的线程数。

• MaxPoolSize(线程池最大容载量)

  线程池最大的线程数，只有在缓冲队列满了之后才会申请超过CorePoolSize的线程。

• QueueCapacity(缓冲队列)

  当CorePoolSize满了之后的线程缓冲的队列。

• KeepAliveSeconds(最大存活秒数)

  超过了核心线程之外的线程在此设定的时间到达后会销毁。

• ThreadNamePrefix(线程名字前缀)

  日志中的线程名称前缀，方便我们查看和分析

• RejectedExecutionHandler(策略处理)

  当线程池没有处理能力的时候，启动的一种对策，一共四种模式，图中说明很详细了。

详细分析

目录结构

└── Study├── pom.xml├── src│   ├── main│   │   ├── java│   │   │   └── top│   │   │       └── yxdz│   │   │           └── study│   │   │               └── spring│   │   │                   └── springboot│   │   │                       ├── thread│   │   │                       │   └── service│   │   │                       │       ├── ITestService.java│   │   │                       │       └── impl│   │   │                       │           └── TestSerivceImpl.java│   │   │                       └── utils│   │   │                           ├── SysThreadValueConfig.java│   │   │                           └── config│   │   │                               └── Thread│   │   │                                   ├── SelfThreadConfig.java│   │   │                                   └── VisiableThreadPoolTaskExecutor.java│   │   └── resources│   │       ├── application.yml│   └── test│       └── java│           └── top│               └── yxdz│                   └── study│                       └── StudyApplicationTests.java

关键代码

• application.yml

  为了打印日志方便，自定义线程池的配置稍微做了修改，数量减少。

  spring:thread:threadNamePrefix: system-thread #线程名称前缀corePoolSize: 2 #核心线程池大小maxPoolSize: 4 #最大线程数keepAliveSeconds: 30 #活跃时间（单位：秒）queueCapacity: 5 #队列容量

• StudyApplicationTests.java

  启动入口。

  package top.yxdz.study;import org.junit.Test;
  import org.junit.runner.RunWith;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  import org.springframework.beans.factory.annotation.Autowired;
  import org.springframework.boot.test.context.SpringBootTest;
  import org.springframework.scheduling.annotation.EnableAsync;
  import org.springframework.test.context.junit4.SpringRunner;
  import top.yxdz.study.spring.springboot.thread.service.ITestService;import java.time.LocalDateTime;@RunWith(SpringRunner.class)
  @SpringBootTest
  @EnableAsync
  public class StudyApplicationTests {private static final Logger LOG = LoggerFactory.getLogger(StudyApplicationTests.class);@AutowiredITestService iTestService;@Testpublic void contextLoads() {for(int i=0; i<15; i++){LOG.info(LocalDateTime.now().toString());iTestService.method2("myself" + i);try {Thread.sleep(1000);}catch (InterruptedException e){e.printStackTrace();}}try {//等待70s，防止异步代码被强制关闭导致线程抛出异常Thread.sleep(70000);}catch (InterruptedException e){e.printStackTrace();}}
  }
  

• TestSerivceImpl.java

  每个线程，均会等待20秒，用来阻塞线程，方便观察线程池工作规则。

  package top.yxdz.study.spring.springboot.thread.service.impl;import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  import org.springframework.scheduling.annotation.Async;
  import org.springframework.stereotype.Service;
  import top.yxdz.study.spring.springboot.thread.service.ITestService;import java.time.LocalDateTime;@Service("TestSerivceImpl")
  public class TestSerivceImpl implements ITestService {private static Logger LOG = LoggerFactory.getLogger(TestSerivceImpl.class);/*** 使用个自定义线程池* @param msg*/@Override@Async("myThreadPool")public void method2(String msg){try {Thread.sleep(20000);}catch (InterruptedException e){e.printStackTrace();}}
  }

运行结果

日志结果太长，可直接进入结果分析。

2018-12-19T20:46:28.630
my-thread-pool, 2.submit, taskCount[0], completedTaskCount[0], activeCount[0], queueSize[0]
2018-12-19T20:46:29.644
my-thread-pool, 2.submit, taskCount[1], completedTaskCount[0], activeCount[1], queueSize[0]
2018-12-19T20:46:30.646
my-thread-pool, 2.submit, taskCount[2], completedTaskCount[0], activeCount[2], queueSize[0]
2018-12-19T20:46:31.650
my-thread-pool, 2.submit, taskCount[3], completedTaskCount[0], activeCount[2], queueSize[1]
2018-12-19T20:46:32.653
my-thread-pool, 2.submit, taskCount[4], completedTaskCount[0], activeCount[2], queueSize[2]
2018-12-19T20:46:33.654
my-thread-pool, 2.submit, taskCount[5], completedTaskCount[0], activeCount[2], queueSize[3]
2018-12-19T20:46:34.655
my-thread-pool, 2.submit, taskCount[6], completedTaskCount[0], activeCount[2], queueSize[4]
2018-12-19T20:46:35.656
my-thread-pool, 2.submit, taskCount[7], completedTaskCount[0], activeCount[2], queueSize[5]
2018-12-19T20:46:36.658
my-thread-pool, 2.submit, taskCount[8], completedTaskCount[0], activeCount[3], queueSize[5]
2018-12-19T20:46:37.671
my-thread-pool, 2.submit, taskCount[9], completedTaskCount[0], activeCount[4], queueSize[5]
2018-12-19T20:46:58.677
my-thread-pool, 2.submit, taskCount[9], completedTaskCount[4], activeCount[4], queueSize[1]
2018-12-19T20:46:59.680
my-thread-pool, 2.submit, taskCount[10], completedTaskCount[4], activeCount[4], queueSize[2]
2018-12-19T20:47:00.685
my-thread-pool, 2.submit, taskCount[11], completedTaskCount[4], activeCount[4], queueSize[3]
2018-12-19T20:47:01.687
my-thread-pool, 2.submit, taskCount[12], completedTaskCount[4], activeCount[4], queueSize[4]
2018-12-19T20:47:02.691
my-thread-pool, 2.submit, taskCount[13], completedTaskCount[4], activeCount[4], queueSize[5]

结果分析

虽然日志不多，但是因为排版问题（有的电脑是两行显示的），可能看起来比较麻烦，故对结果结果进行一次再提炼和统计，更加直观。（注：线程池满，采用的是CallerRunsPolicy策略）

• 序号1~序号2

  每秒一个异步线程，线程池的核心线程数为2，故运行中的线程数一直递增，直到达到2。

• 序号3~序号8

  从序号3开始，因为核心线程数已经满了，故新增的线程将放入队列进行缓存，故运行的线程数不变，队列缓存的线程数递增。

• 序号9~序号10

  这两个异步线程进来的时候，核心线程数已满，队列缓存的也满了，并且核心线程数小于MaxPoolSize，故核心线程数开始上升，直到到达MaxPoolSize。

• 序号11~序号15

  从序号10到序号11，中间相差了20秒，到达序号11的时候，突然四个线程被完成了，而非一个个慢慢完成。造成这种情况的原因是因为采取的RejectedExecutionHandler(策略)导致的。
          CallerRunsPolicy策略表示，当线程池没有处理能力的时候，该策略会直接在execute方法的调用线程中执行。也就是说，在序号10的时候，主线程被用来执行本该分配的异步线程，导致主线程阻塞，直到该任务运行完毕。而在这期间，异步线程已经完成了四个(及MaxPoolSize，大家可以想象为啥)，所以已完成线程数为4，队列中也就空出可以缓存新的异步任务的空间。

参考文章

Spring Boot线程池的使用心得

Springboot学习笔记（一）-线程池的简化及使用