线程池原理

最新推荐文章于 2024-09-15 19:13:56 发布

也拟泛轻舟~

最新推荐文章于 2024-09-15 19:13:56 发布

阅读量97

点赞数 1

文章标签：服务器 java 运维线程池

本文链接：https://blog.csdn.net/chenxuezhou/article/details/122147560

版权

在web开发中，服务器需要接受并处理请求，所以会为一个请求来分配一个线程来进行处理。如果每次请求都新创建一个线程的话实现起来非常简便，但是存在一个问题：如果并发的请求数量非常多，但每个线程执行的时间很短，这样就会频繁的创建和销毁线程，如此一来会大大降低系统的效率。可能出现服务器在为每个请求创建新线程和销毁线程上花费的时间和消耗的系统资源要比处理实际的用户请求的时间和资源更多。

线程池：
顾名思义就是一个线程缓存，当线程执行完一个任务，并不被销毁，而是可以继续执行其他的任务。线程池为线程生命周期的开销和资源不足问题提供了解决方案。通过对多个任务重用线程，线程创建的开销被分摊到了多个任务上

什么时候使用线程池？
单个任务处理时间比较短
需要处理的任务数量很大

线程池优势：
重用存在的线程，减少线程创建，消亡的开销，提高性能
提高响应速度。当任务到达时，任务可以不需要的等到线程创建就能立即执行。
提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。

线程池中通过整型（32bate）变量一分为二来记录线程状态和线程池中当前活跃线程数高三位记录线程状态低29位记录线程池中当前活跃线程数

线程池存在5种状态：

1 RUNNING = ‐1 << COUNT_BITS; //高3位为111
2 SHUTDOWN = 0 << COUNT_BITS; //高3位为000
3 STOP = 1 << COUNT_BITS; //高3位为001
4 TIDYING = 2 << COUNT_BITS; //高3位为010
5 TERMINATED = 3 << COUNT_BITS; //高3位为011

1、RUNNING
(1) 状态说明：线程池处在RUNNING状态时，能够接收新任务，以及对已添加的任务进行处理。
(2) 状态切换：线程池的初始化状态是RUNNING。换句话说，线程池被一旦被创建，就处于RUNNING状态，并且线程池中的任务数为0！
2、 SHUTDOWN
(1) 状态说明：线程池处在SHUTDOWN状态时，不接收新任务，但能处理已添加的任务。
(2) 状态切换：调用线程池的shutdown()接口时，线程池由RUNNING -> SHUTDOWN。
3、STOP
(1) 状态说明：线程池处在STOP状态时，不接收新任务，不处理已添加的任务，并且会中断正在处理的任务。
(2) 状态切换：调用线程池的shutdownNow()接口时，线程池由(RUNNING orSHUTDOWN ) -> STOP。
4、TIDYING
(1) 状态说明：当所有的任务已终止，ctl记录的”任务数量”为0，线程池会变为TIDYING状态。当线程池变为TIDYING状态时，会执行钩子函数terminated()。terminated()在ThreadPoolExecutor类中是空的，若用户想在线程池变为TIDYING时，进行相应的处理；可以通过重载terminated()函数来实现。
(2) 状态切换：当线程池在SHUTDOWN状态下，阻塞队列为空并且线程池中执行的任务也为空时，就会由 SHUTDOWN -> TIDYING。当线程池在STOP状态下，线程池中执行的任务为空时，就会由STOP -> TIDYING。
5、 TERMINATED
(1) 状态说明：线程池彻底终止，就变成TERMINATED状态。
(2) 状态切换：线程池处在TIDYING状态时，执行完terminated()之后，就会由 TIDYING -> TERMINATED。

在这里插入图片描述
ThreadPoolExecutor线程池的创建

1 public ThreadPoolExecutor(int corePoolSize,
2  int maximumPoolSize,
3  long keepAliveTime,
4  TimeUnit unit,
5  BlockingQueue<Runnable> workQueue,
6  ThreadFactory threadFactory,
7  RejectedExecutionHandler handler)

参数解释
corePoolSize
线程池中的核心线程数，当提交一个任务时，线程池创建一个新线程执行任务，直到当前线程数等于corePoolSize；如果当前线程数为corePoolSize，继续提交的任务被保存到阻塞队列中，等待被执行；如果执行了线程池的prestartAllCoreThreads()方法，线程池会提前创建并启动所有核心线程。
maximumPoolSize
线程池中允许的最大线程数。如果当前阻塞队列满了，且继续提交任务，则创建新的线程执行任务，前提是当前线程数小于maximumPoolSize；
keepAliveTime
线程池维护线程所允许的空闲时间。当线程池中的线程数量大于corePoolSize的时候，如果这时没有新的任务提交，核心线程外的线程不会立即销毁，而是会等待，直到等待的时间超过了keepAliveTime；
unit
keepAliveTime的单位；
workQueue
用来保存等待被执行的任务的阻塞队列，且任务必须实现Runable接口，在JDK中提供了如下阻塞队列：
1、ArrayBlockingQueue：基于数组结构的有界阻塞队列，按FIFO排序任务；
2、LinkedBlockingQuene：基于链表结构的阻塞队列，按FIFO排序任务，吞吐量通常要高于ArrayBlockingQuene；
3、SynchronousQuene：一个不存储元素的阻塞队列，每个插入操作必须等到另一个线程调用移除操作，否则插入操作一直处于阻塞状态，吞吐量通常要高于LinkedBlockingQuene；
4、priorityBlockingQuene：具有优先级的无界阻塞队列；
threadFactory
它是ThreadFactory类型的变量，用来创建新线程。默认使用Executors.defaultThreadFactory() 来创建线程。使用默认的ThreadFactory来创建线程时，会使新创建的线程具有相同的NORM_PRIORITY优先级并且是非守护线程，同时也设置了线程的名称。
handler
线程池的饱和策略，当阻塞队列满了，且没有空闲的工作线程，如果继续提交任务，必须采取一种策略处理该任务，线程池提供了4种略：
1、AbortPolicy：直接抛出异常，默认策略；
2、CallerRunsPolicy：用调用者所在的线程来执行任务；
3、DiscardOldestPolicy：丢弃阻塞队列中靠最前的任务，并执行当前任务；
4、DiscardPolicy：直接丢弃任务；
上面的4种策略都是ThreadPoolExecutor的内部类。
当然也可以根据应用场景实现RejectedExecutionHandler接口，自定义饱和策略，如记录日志或持久化存储不能处理的任务。

线程池原理：
在这里插入图片描述
execute方法源码分析

1 public void execute(Runnable command) {
2  if (command == null)
3  throw new NullPointerException();
4 /*
5  * clt记录着runState和workerCount
6  */
7  int c = ctl.get();
8 /*
9  * workerCountOf方法取出低29位的值，表示当前活动的线程数；
10  * 如果当前活动线程数小于corePoolSize，则新建一个线程放入线程池中；
11  * 并把任务添加到该线程中。
12  */
13  if (workerCountOf(c) < corePoolSize) {
14 /*
15  * addWorker中的第二个参数表示限制添加线程的数量是根据corePoolSize
来判断还是maximumPoolSize来判断；
16  * 如果为true，根据corePoolSize来判断；
17  * 如果为false，则根据maximumPoolSize来判断
18  */
19  if (addWorker(command, true))
20  return;
21 /*
22  * 如果添加失败，则重新获取ctl值
23  */
24  c = ctl.get();
25  }
26 /*
27  * 如果当前线程池是运行状态并且任务添加到队列成功
28  */
29  if (isRunning(c) && workQueue.offer(command)) {
30 // 重新获取ctl值
31  int recheck = ctl.get();
32  // 再次判断线程池的运行状态，如果不是运行状态，由于之前已经把command
添加到workQueue中了，
33 // 这时需要移除该command
34 // 执行过后通过handler使用拒绝策略对该任务进行处理，整个方法返回
35  if (! isRunning(recheck) && remove(command))
36  reject(command);
37 /*
38  * 获取线程池中的有效线程数，如果数量是0，则执行addWorker方法
39  * 这里传入的参数表示：
40  * 1. 第一个参数为null，表示在线程池中创建一个线程，但不去启动；
41  * 2. 第二个参数为false，将线程池的有限线程数量的上限设置为maximumPo
olSize，添加线程时根据maximumPoolSize来判断；
42  * 如果判断workerCount大于0，则直接返回，在workQueue中新增的command
会在将来的某个时刻被执行。
43  */
44  else if (workerCountOf(recheck) == 0)
45  addWorker(null, false);
46  }
47 /*
48  * 如果执行到这里，有两种情况：
49  * 1. 线程池已经不是RUNNING状态；
50  * 2. 线程池是RUNNING状态，但workerCount >= corePoolSize并且workQ
ueue已满。
51  * 这时，再次调用addWorker方法，但第二个参数传入为false，将线程池的
有限线程数量的上限设置为maximumPoolSize；
52  * 如果失败则拒绝该任务
53  */
54  else if (!addWorker(command, false))
55  reject(command);
56 }

在执行execute()方法时如果状态一直是RUNNING时，的执行过程如下：

如果workerCount < corePoolSize，则创建并启动一个线程来执行新提交的任务；
如果workerCount >= corePoolSize，且线程池内的阻塞队列未满，则将任务添加到该阻塞队列中；
如果 workerCount >= corePoolSize && workerCount <maximumPoolSize，且线程池内的阻塞队列已满，则创建并启动一个线程来执行新提交的任务；
如果workerCount >= maximumPoolSize，并且线程池内的阻塞队列已满, 则根据拒绝策略来处理该任务, 默认的处理方式是直接抛异常。
这里要注意一下addWorker(null, false);，也就是创建一个线程，但并没有传入任务，因为任务已经被添加到workQueue中了，所以worker在执行的时候，会直接从workQueue中获取任务。所以，在workerCountOf(recheck) == 0时执行addWorker(null, false);也是为了保证线程池在RUNNING状态下必须要有一个线程来执行任务。
execute方法执行流程如下：

addWorker方法源码：
addWorker方法的主要工作是在线程池中创建一个新的线程并执行，firstTask参数用于指定新增的线程执行的第一个任务，core参数为true表示在新增线程时会判断当前活动线程数是否少于corePoolSize，false表示新增线程前需要判断当前活动线程数是否少于maximumPoolSize，代码如下：

1 private boolean addWorker(Runnable firstTask, boolean core) {
2  retry:
3  for (;;) {
4  int c = ctl.get();
5  // 获取运行状态
6  int rs = runStateOf(c);
7  /*
8  * 这个if判断
9  * 如果rs >= SHUTDOWN，则表示此时不再接收新任务；
10  * 接着判断以下3个条件，只要有1个不满足，则返回false：
11  * 1. rs == SHUTDOWN，这时表示关闭状态，不再接受新提交的任务，但却可
以继续处理阻塞队列中已保存的任务
12  * 2. firsTask为空
13  * 3. 阻塞队列不为空
14  *
15  * 首先考虑rs == SHUTDOWN的情况
16  * 这种情况下不会接受新提交的任务，所以在firstTask不为空的时候会返回f
alse；
17  * 然后，如果firstTask为空，并且workQueue也为空，则返回false，
18  * 因为队列中已经没有任务了，不需要再添加线程了
19  */
20  // Check if queue empty only if necessary.
21  if (rs >= SHUTDOWN &&
22  ! (rs == SHUTDOWN &&
23  firstTask == null &&
24  ! workQueue.isEmpty()))
25  return false;
26  for (;;) {
27  // 获取线程数
28  int wc = workerCountOf(c);
29  // 如果wc超过CAPACITY，也就是ctl的低29位的最大值（二进制是29个1），
返回false；
30  // 这里的core是addWorker方法的第二个参数，如果为true表示根据corePo
olSize来比较，
31  // 如果为false则根据maximumPoolSize来比较。
32  //
33  if (wc >= CAPACITY ||
34  wc >= (core ? corePoolSize : maximumPoolSize))
35  return false;
36  // 尝试增加workerCount，如果成功，则跳出第一个for循环
37  if (compareAndIncrementWorkerCount(c))
38  break retry;
39  // 如果增加workerCount失败，则重新获取ctl的值
40  c = ctl.get(); // Re‐read ctl
41  // 如果当前的运行状态不等于rs，说明状态已被改变，返回第一个for循环继
续执行
42  if (runStateOf(c) != rs)
43  continue retry;
44  // else CAS failed due to workerCount change; retry inner loop
45  }
46  }
47  boolean workerStarted = false;
48  boolean workerAdded = false;
49  Worker w = null;
50  try {
51  // 根据firstTask来创建Worker对象
52  w = new Worker(firstTask);
53  // 每一个Worker对象都会创建一个线程
54  final Thread t = w.thread;
55  if (t != null) {
56  final ReentrantLock mainLock = this.mainLock;
57  mainLock.lock();
58  try {
59  int rs = runStateOf(ctl.get());
60  // rs < SHUTDOWN表示是RUNNING状态；
61  // 如果rs是RUNNING状态或者rs是SHUTDOWN状态并且firstTask为null，向
线程池中添加线程。
62  // 因为在SHUTDOWN时不会在添加新的任务，但还是会执行workQueue中的任
务
63  if (rs < SHUTDOWN ||
64  (rs == SHUTDOWN && firstTask == null)) {
65  if (t.isAlive()) // precheck that t is startable
66  throw new IllegalThreadStateException();
67  // workers是一个HashSet
68  workers.add(w);
69  int s = workers.size();
70  // largestPoolSize记录着线程池中出现过的最大线程数量
71  if (s > largestPoolSize)
72  largestPoolSize = s;
73  workerAdded = true;
74  }
75  } finally {
76  mainLock.unlock();
77  }
78  if (workerAdded) {
79  // 启动线程
80  t.start();
81  workerStarted = true;
82  }
83  }
84  } finally {
85  if (! workerStarted)
86  addWorkerFailed(w);
87  }
88  return workerStarted;
89 }

Worker类
线程池中的每一个线程被封装成一个Worker对象，ThreadPool维护的其实就是一组Worker对象
Worker类继承了AQS，并实现了Runnable接口，注意其中的firstTask和thread属性：firstTask用它来保存传入的任务；thread是在调用构造方法时通过ThreadFactory来创建的线程，是用来处理任务的线程。在调用构造方法时，需要把任务传入，这里通过getThreadFactory().newThread(this);来新建一个线程，newThread方法传入的参数是this，因为Worker本身继承了Runnable接口，也就是一个线程，所以一个Worker对象在启动的时候会调用Worker类中的run方法。Worker继承了AQS，使用AQS来实现独占锁的功能。为什么不使用ReentrantLock来实现呢？可以看到tryAcquire方法，它是不允许重入的，而ReentrantLock是允许重入的：

lock方法一旦获取了独占锁，表示当前线程正在执行任务中；
如果正在执行任务，则不应该中断线程；
如果该线程现在不是独占锁的状态，也就是空闲的状态，说明它没有在处理任务，这时可以对该线程进行中断；
线程池在执行shutdown方法或tryTerminate方法时会调用interruptIdleWorkers方法来中断空闲的线程，interruptIdleWorkers方法会使用tryLock方法来判断线程池中的线程是否是空闲状态；
之所以设置为不可重入，是因为我们不希望任务在调用像setCorePoolSize这样的线程池控制方法时重新获取锁。如果使用ReentrantLock，它是可重入的，这样如果在任务中调用了如setCorePoolSize这类线程池控制的方法，会中断正在运行的线程。
所以，Worker继承自AQS，用于判断线程是否空闲以及是否可以被中断。此外，在构造方法中执行了setState(-1);，把state变量设置为-1，为什么这么做呢？是因为AQS中默认的state是0，如果刚创建了一个Worker对象，还没有执行任务时，这时就不应该被中断，看一下tryAquire方法：

1 protected boolean tryAcquire(int unused) {
2 //cas修改state，不可重入
3  if (compareAndSetState(0, 1)) {
4  setExclusiveOwnerThread(Thread.currentThread());
5  return true;
6  }
7  return false;
8 }

tryAcquire方法是根据state是否是0来判断的，所以，setState(-1);将state设置为-1是为了禁止在执行任务前对线程进行中断。
正因为如此，在runWorker方法中会先调用Worker对象的unlock方法将state设置为0。
runWorker方法
在Worker类中的run方法调用了runWorker方法来执行任务，runWorker方法的代码如下：

1 final void runWorker(Worker w) {
2  Thread wt = Thread.currentThread();
3  // 获取第一个任务
4  Runnable task = w.firstTask;
5  w.firstTask = null;
6  // 允许中断
7  w.unlock(); // allow interrupts
8  // 是否因为异常退出循环
9  boolean completedAbruptly = true;
10  try {
11  // 如果task为空，则通过getTask来获取任务
12  while (task != null || (task = getTask()) != null) {
13  w.lock();
14  if ((runStateAtLeast(ctl.get(), STOP) ||
15  (Thread.interrupted() &&
16  runStateAtLeast(ctl.get(), STOP))) &&
17  !wt.isInterrupted())
18  wt.interrupt();
19  try {
20  beforeExecute(wt, task);
21  Throwable thrown = null;
22  try {
23  task.run();
24  } catch (RuntimeException x) {
25  thrown = x; throw x;
26  } catch (Error x) {
27  thrown = x; throw x;
28  } catch (Throwable x) {
29  thrown = x; throw new Error(x);
30  } finally {
31  afterExecute(task, thrown);
32  }
33  } finally {
34  task = null;
35  w.completedTasks++;
36  w.unlock();
37  }
38  }
39  completedAbruptly = false;
40  } finally {
41  processWorkerExit(w, completedAbruptly);
42  }
43 }

第一个if判断，目的是：
如果线程池正在停止，那么要保证当前线程是中断状态；
如果不是的话，则要保证当前线程不是中断状态；
这里要考虑在执行该if语句期间可能也执行了shutdownNow方法，shutdownNow方法会把状态设置为STOP，回顾一下STOP状态：
不能接受新任务，也不处理队列中的任务，会中断正在处理任务的线程。在线程池处于RUNNING 或 SHUTDOWN 状态时，调用 shutdownNow() 方法会使线程池进入到该状态。
STOP状态要中断线程池中的所有线程，而这里使用Thread.interrupted()来判断是否中断是为了确保在 RUNNING 或者 SHUTDOWN 状态时线程是非中断状态的，因为Thread.interrupted()方法会复位中断的状态。
总结一下runWorker方法的执行过程：

while循环不断地通过getTask()方法获取任务；
getTask()方法从阻塞队列中取任务；
如果线程池正在停止，那么要保证当前线程是中断状态，否则要保证当前线程不是中断状态；
调用task.run()执行任务；
如果task为null则跳出循环，执行processWorkerExit()方法；
runWorker方法执行完毕，也代表着Worker中的run方法执行完毕，销毁线程。这里的beforeExecute方法和afterExecute方法在ThreadPoolExecutor类中是空的，留给子类来实现。
completedAbruptly 变量来表示在执行任务过程中是否出现了异常，在processWorkerExit方法中会对该变量的值进行判断。

getTask方法用来从阻塞队列中取任务，代码如下：

1 private Runnable getTask() {
2  // timeOut变量的值表示上次从阻塞队列中取任务时是否超时
3  boolean timedOut = false; // Did the last poll() time out?
4  for (;;) {
5  int c = ctl.get();
6  int rs = runStateOf(c);
7  // Check if queue empty only if necessary.
8  /*
9  * 如果线程池状态rs >= SHUTDOWN，也就是非RUNNING状态，再进行以下判
断：
10  * 1. rs >= STOP，线程池是否正在stop；
11  * 2. 阻塞队列是否为空。
12  * 如果以上条件满足，则将workerCount减1并返回null。
13  * 因为如果当前线程池状态的值是SHUTDOWN或以上时，不允许再向阻塞队列中
添加任务。
14  */
15  if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
16  decrementWorkerCount();
17  return null;
18  }
19  int wc = workerCountOf(c);
20  // Are workers subject to culling?
21  // timed变量用于判断是否需要进行超时控制。
22  // allowCoreThreadTimeOut默认是false，也就是核心线程不允许进行超
时；
23  // wc > corePoolSize，表示当前线程池中的线程数量大于核心线程数量；
24  // 对于超过核心线程数量的这些线程，需要进行超时控制
25  boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
26 
27  /*
28  * wc > maximumPoolSize的情况是因为可能在此方法执行阶段同时执行了se
tMaximumPoolSize方法；
29  * timed && timedOut 如果为true，表示当前操作需要进行超时控制，并且
上次从阻塞队列中获取任务发生了超时
30  * 接下来判断，如果有效线程数量大于1，或者阻塞队列是空的，那么尝试将w
orkerCount减1；
31  * 如果减1失败，则返回重试。
32  * 如果wc == 1时，也就说明当前线程是线程池中唯一的一个线程了。
33  */
34  if ((wc > maximumPoolSize || (timed && timedOut))
35  && (wc > 1 || workQueue.isEmpty())) {
36  if (compareAndDecrementWorkerCount(c))
37  return null;
38  continue;
39  }
40  try {
41  /*
42  * 根据timed来判断，如果为true，则通过阻塞队列的poll方法进行超时控
制，如果在keepAliveTime时间内没有获取到任务，则返回null；
43  * 否则通过take方法，如果这时队列为空，则take方法会阻塞直到队列不为
空。
44  *
45  */
46  Runnable r = timed ?
47  workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
48  workQueue.take();
49  if (r != null)
50  return r;
51  // 如果 r == null，说明已经超时，timedOut设置为true
52  timedOut = true;
53  } catch (InterruptedException retry) {
54  // 如果获取任务时当前线程发生了中断，则设置timedOut为false并返回循
环重试
55  timedOut = false;
56  }
57  }
58 }

这里重要的地方是第二个if判断，目的是控制线程池的有效线程数量。由上文中的分析可以知道，在执行execute方法时，如果当前线程池的线程数量超过了corePoolSize且小于maximumPoolSize，并且workQueue已满时，则可以增加工作线程，但这时如果超时没有获取到任务，也就是timedOut为true的情况，说明workQueue已经为空了，也就说明了当前线程池中不需要那么多线程来执行任务了，可以把多于corePoolSize数量的线程销毁掉，保持线程数量在corePoolSize即可。
什么时候会销毁？当然是runWorker方法执行完之后，也就是Worker中的run方法执行完，由JVM自动回收。
getTask方法返回null时，在runWorker方法中会跳出while循环，然后会执行processWorkerExit方法。
processWorkerExit方法：

1 private void processWorkerExit(Worker w, boolean completedAbrupt
ly) {
2  // 如果completedAbruptly值为true，则说明线程执行时出现了异常，需要
将workerCount减1；
3  // 如果线程执行时没有出现异常，说明在getTask()方法中已经已经对worker
Count进行了减1操作，这里就不必再减了。
4  if (completedAbruptly) // If abrupt, then workerCount wasn't ad
justed
5  decrementWorkerCount();
6  final ReentrantLock mainLock = this.mainLock;
7  mainLock.lock();
8  try {
9  //统计完成的任务数
10  completedTaskCount += w.completedTasks;
11  // 从workers中移除，也就表示着从线程池中移除了一个工作线程
12  workers.remove(w);
13  } finally {
14  mainLock.unlock();
15  }
16  // 根据线程池状态进行判断是否结束线程池
17  tryTerminate();
18  int c = ctl.get();
19 /*
20  * 当线程池是RUNNING或SHUTDOWN状态时，如果worker是异常结束，那么会
直接addWorker；
21  * 如果allowCoreThreadTimeOut=true，并且等待队列有任务，至少保留一
个worker；
22  * 如果allowCoreThreadTimeOut=false，workerCount不少于corePoolSiz
e。
23  */
24  if (runStateLessThan(c, STOP)) {
25  if (!completedAbruptly) {
26  int min = allowCoreThreadTimeOut ? 0 : corePoolSize;
27  if (min == 0 && ! workQueue.isEmpty())
28  min = 1;
29  if (workerCountOf(c) >= min)
30  return; // replacement not needed
31  }
32  addWorker(null, false);
33  }
34 }

至此，processWorkerExit执行完之后，工作线程被销毁，以上就是整个工作线程的生命周期，从execute方法开始，Worker使用ThreadFactory创建新的工作线程，runWorker通过getTask获取任务，然后执行任务，如果getTask返回null，进入processWorkerExit方法

最后我们来看一个问题比如现在核心和最大线程数为1 当前有多个任务那我当我线程执行第一个任务抛出异常的时候后面的任务还会执行吗？
会因为如果是抛出异常线程池中的逻辑是会把当前线程移除掉然后在创建一个线程去执行任务

总结：
当有新任务来的时候，先看看当前的线程数有没有超过核心线程数，如果没超过就直接新建一个线程来执行新的任务，如果超过了就看看缓存队列有没有满，没满就将新任务放进缓存队列中，满了就新建一个线程来执行新的任务，如果线程池中的线程数已经达到了指定的最大线程数了，那就根据相应的策略拒绝任务。
当缓存队列中的任务都执行完了的时候，线程池中的线程数如果大于核心线程数，就销毁多出来的线程，直到线程池中的线程数等于核心线程数。此时这些线程就不会被销毁了，它们一直处于阻塞状态，等待新的任务到来。
注意：
本文所说的“核心线程”、“非核心线程”是一个虚拟的概念，是为了方便描述而虚拟出来的概念，在代码中并没有哪个线程被标记为“核心线程”或“非核心线程”，所有线程都是一样的，只是当线程池中的线程多于指定的核心线程数量时，会将多出来的线程销毁掉，池中只保留指定个数的线程。那些被销毁的线程是随机的，可能是第一个创建的线程，也可能是最后一个创建的线程，或其它时候创建的线程。一开始我以为会有一些线程被标记为“核心线程”，而其它的则是“非核心线程”，在销毁多余线程的时候只销毁那些“非核心线程”，而“核心线程”不被销毁。这种理解是错误的。

工作中核心线程数的设置，我们可以参考下面两种方法：
Cpu密集型： Cup数量+1（现代cpu支持超线程）
IO密集型： 一般2倍cup数