滥用线程，导致线上线程池被撑爆的一次意外

事故的背景

简单的描述一下业务场景，项目里面有一个分布式定时job ，定期去扒取数据，那么有两层循环，第一层是大概1000条数据
，然后第二层循环每个数据下面大概20个子数据，然后通过多线程的方式去扒取数据入库。这就是一个简单的业务背景。这个对刚入行的小白写代码得注意了！

作为程序员的我也是第一次遇到这个问题，虽然这个问题解决很简单，但是造成的影响很大，我觉得还是有必要做一个小总结，小伙伴们以后写类似代码的时候就会有注意，这个问题的造成是我一个同事没有理解透线程池，导致的一个很大的问题。那么先说问题之前先扒拉扒拉线程池。

线程池

首先我先说明一点在企业中一般都是自定义线程池，很少使用jdk 给我们提供的几种线程池方法，这样是为了做到一个可控制。

这里帮大家只是一次简单的回顾吧，具体线程池网上已经一大片一大片的文章了。

  public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,BlockingQueue<Runnable> workQueue,RejectedExecutionHandler handler) private static ThreadPoolExecutor poolExecutor = newThreadPoolExecutor(3,30,1,TimeUnit.MINUTES,new ArrayBlockingQueue(1000),new MyRejectedExecutionHandler(MAX_QUEUE_SIZE));

那么说到线程池无非就理解这几个参数。

流程

假如我们定义的corePoolSize 是5个 maximunPoolSize 是 30， keepAliveTime为一分钟，队列大概1000个吧
第1个Task来了放入到队列里面，线程池一直从队列里面获取，获取到第一个Task，发现当前线程池里面线程个数小于corePoolSize ，欧克欧克，兄弟我马上给你创建一个线程。
此时第2个Task 又来了，线程池又从队列里面获取，发现现在的线程还是小于corePoolSize，马上又开启新的线程继续执行
此时第5个Task 来了，那么和corePoolSize 相等了，ok ,那么继续创建一个线程。对于创建的这5个线程是不会销毁的，这也是为什么线程池可以避免重复创建线程代来的消耗。
此时第6个Task 来了，线程池发现corePoolSize 里面有刚刚执行完了的线程，那么此时就不需要创建新的线程了，直接拿来使用，达到了一个复用的效果。
假如我们的Task 很多很多，又比较耗时，corePoolSize 已经没有空闲的线程了，那么接下来就是maximumPoolSize出场了，发现线程池里面此时corePoolSize < num < maximumPoolSize
那么继续创建线程执行Task
那么当线程池数量num > maximumPoolSize,就不会创建新的线程，来的新的Task直接往队列里面仍进去
当队列里面都已经超过了最大数量(我们这里定义的1000) ，相当我们线程池已经爆满了没法接收新的Task了，那么不好意思兄弟，我只能拒绝你了，然后就走我们的MyRejectedExecutionHandler
上面的参数基本已经提到了，还剩一个keepAliveTime 那么这个时间又什么时候用呢，这种场景下corePoolSize < num < maximumPoolSize 超过corePoolSize 空闲的线程的存活时间，比如核心是5个，最大30个，那么多余的25个线程就是超出的线程，简单的总结就是：超出核心线程的线程存活的时间。

那么上面也是整个线程池的核心流程做了一个描述。

自定义线程池

上面已经描述了线程池的流程和原理，下面自定义线程池直接贴代码了，就不做过多的阐述了。

// 定义一个线程池类
public class MyWorkerThreadPool {private static final int MAX_QUEUE_SIZE = 1000;private static ThreadPoolExecutor poolExecutor = newThreadPoolExecutor(3,30,1,TimeUnit.MINUTES,new ArrayBlockingQueue(MAX_QUEUE_SIZE),new MyRejectedExecutionHandler(MAX_QUEUE_SIZE));public static void submitTak(Runnable run) {poolExecutor.submit(run);}public static void shutdown() {poolExecutor.shutdown();}
}// 定义一个拒绝策略public class MyRejectedExecutionHandler implements RejectedExecutionHandler{private final Log logger = LogFactory.getLog(this.getClass());private int  maxQueueSize;public MyRejectedExecutionHandler(int maxQueueSize){this.maxQueueSize=maxQueueSize;}@Overridepublic void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {System.out.println("提交任务失败了" +"当前队列最大长度" +"maxQueueSize="+maxQueueSize+",maximumPoolSize="+executor.getMaximumPoolSize());if(executor.getQueue().size()<maxQueueSize){executor.submit(r);}else{try {Thread.sleep(3000);executor.submit(r);}catch (Exception e){//此异常忽略executor.submit(r);}}}
}

事故代码(伪代码)

那么接下来就是重点了，这里只贴一部分伪代码，前面已经说了这是一个分布式定时job，这里是我精简了同事的代码提炼出来的。

 //模拟场景for(int i= 0;i< 1000;i++){for(int j = 0;j<20;j++){MyWorkerThreadPool.submitTak(()->{// 真实业务场景这里非常耗时，try {Thread.sleep(5000);} catch (InterruptedException e) {e.printStackTrace();}});}}执行结果:
提交任务失败了当前队列最大长度maxQueueSize=1000,maximumPoolSize=30
提交任务失败了当前队列最大长度maxQueueSize=1000,maximumPoolSize=30
提交任务失败了当前队列最大长度maxQueueSize=1000,maximumPoolSize=30
提交任务失败了当前队列最大长度maxQueueSize=1000,maximumPoolSize=30
提交任务失败了当前队列最大长度maxQueueSize=1000,maximumPoolSize=30

这里第一层模拟了1000条数据，第二层循环30条数据，同事的代码，导致同一时间我们自定义的线程队列爆满，2000*30 这个是要开多少个线程啊。细细想下是不是很恐怖，这么使用会导致什么后果呢，当前业务又很多都被拒绝掉没有执行，另外当线程池爆满后，我们项目的其它功能执行异步方法也会被拒绝掉，结果可想而知。

那么如何解决了，其实很简单，我们跑这个比较耗时的任务我们可以指定10个线程去跑就是了，这样就不会影响到其它的功能业务。
我这里简单的使用了一个计数器，比如超过了10个线程则阻塞等待一会，跑完一个线程则减一，直接上代码

public class TestMain {public static void main(String[] args) throws Exception{//模拟场景，这是一个分布式定时任务，所以不会存在并发同时执行的问题AtomicInteger threadNum = new AtomicInteger(0);// 模拟当前第一层有1000数据for(int i= 0;i< 1000;i++){// 模拟每条线路有20条子数据for(int j = 0;j<20;j++){// 多线程拉去爬取网上的数据汇总到数据库// 一次最多开启10个线程取执行耗时操作,while (threadNum.get() > 10){// 可以小睡一会再看是否有资格执行Thread.sleep(500);}// 小增加1threadNum.incrementAndGet();int tempI = i;int tempJ = j;MyWorkerThreadPool.submitTak(()->{// 真实业务场景这里非常耗时，try {Thread.sleep(5000);System.out.println(Thread.currentThread().getName()+"执行完第一层数据"+ tempI +"第二层:"+tempJ);// 执行完减少一个1threadNum.decrementAndGet();} catch (InterruptedException e) {e.printStackTrace();}});}}}执行结果:
pool-2-thread-2执行完第一层数据0第二层:1
pool-2-thread-1执行完第一层数据0第二层:0
pool-2-thread-3执行完第一层数据0第二层:2
pool-2-thread-2执行完第一层数据0第二层:3
pool-2-thread-3执行完第一层数据0第二层:5
pool-2-thread-1执行完第一层数据0第二层:4
pool-2-thread-3执行完第一层数据0第二层:7
pool-2-thread-1执行完第一层数据0第二层:8
pool-2-thread-2执行完第一层数据0第二层:6
pool-2-thread-1执行完第一层数据0第二层:10
pool-2-thread-3执行完第一层数据0第二层:9
pool-2-thread-2执行完第一层数据0第二层:11
pool-2-thread-3执行完第一层数据0第二层:13
pool-2-thread-2执行完第一层数据0第二层:14
pool-2-thread-1执行完第一层数据0第二层:12

总结

其实我们开发中又很多小细节，只是我们有时候没有注意或对其原理不清楚，有时候写出来的代码就会带来比较糟糕的后果。那么今天这篇就到这里！