先来看看线程池的类图（借用了别人的图）：
可以看到，Executor是顶层的一个接口，线程池的实现类是ScheduledThreadPoolExecutor和ThreadPoolExecutor，而Executors是一个工具类，用于创建实际的线程池，接下来看看源码。
点进源码查看（是 JDK1.8 版本加入的一种线程池，stealing 翻译为抢断、窃取的意思，它实现的一个线程池和上面4种都不一样，用的是 ForkJoinPool 类），以CachedThreadPool为例：
可以看到实际创建的就是一个ThreadPoolExecutor
接下来简单介绍
1.生命周期管理
线程池内部使用一个变量维护两个值：运行状态(runState)和线程数量 (workerCount)。在具体实现中，线程池将运行状态(runState)、线程数量 (workerCount)两个关键参数的维护放在了一起。
它同时包含两部分的信息：线程池的运行状态 (runState) 和线程池内有效线程的数量 (workerCount)，高3位保存runState，低29位保存workerCount，两个变量之间互不干扰。用一个变量去存储两个值，可避免在做相关决策时，出现不一致的情况，不必为了维护两者的一致，而占用锁资源。
ThreadPoolExecutor有5种状态：
RUNNING 能接受新提交的任务，并且也能处理阻塞队列中的任务SHUTDOWN 关闭状态，不再接受新提交的任务，却可以继续处理保存在阻塞队列中的任务STOP 不能接受新的任务，也不处理队列中的任务，会中断正在处理任务的线程TIDYING 所有的任务都已终止，workCount（有效线程数）为0TERMINATED 在terminated()方法执行完后进入该状态2.任务执行机制
首先检测线程池运行状态，如果不是RUNNING，则直接拒绝，线程池要保证在RUNNING的状态下执行任务。如果workerCount < corePoolSize，则创建并启动一个线程来执行新提交的任务。如果workerCount >= corePoolSize，且线程池内的阻塞队列未满，则将任务添加到该阻塞队列中。如果workerCount >= corePoolSize && workerCount < maximumPoolSize，且线程池内的阻塞队列已满，则创建并启动一个线程来执行新提交的任务。如果workerCount >= maximumPoolSize，并且线程池内的阻塞队列已满, 则根据拒绝策略来处理该任务, 默认的处理方式是直接抛异常。见上图CachedThreadPool的创建，可以看到传递了阻塞队列，阻塞队列根据不同的线程池用了不一样的阻塞队列：
如上执行机制提到拒绝策略，当线程池的任务缓存队列已满，并且线程池中的线程数目达到maximumPoolSize时，就需要拒绝掉该任务，采取任务拒绝策略。
拒绝策略是一个接口：
简单介绍如何实现线程复用，
逐一方法进行讲解，自然先看看execute方法，execute意为执行，所以线程池执行都会调用到此方法，
public void execute(Runnable command) { if (command == null) throw new NullPointerException(); /* * Proceed in 3 steps: * * 1. If fewer than corePoolSize threads are running, try to * start a new thread with the given command as its first * task. The call to addWorker atomically checks runState and * workerCount, and so prevents false alarms that would add * threads when it shouldn't, by returning false. * * 2. If a task can be successfully queued, then we still need * to double-check whether we should have added a thread * (because existing ones died since last checking) or that * the pool shut down since entry into this method. So we * recheck state and if necessary roll back the enqueuing if * stopped, or start a new thread if there are none. * * 3. If we cannot queue task, then we try to add a new * thread. If it fails, we know we are shut down or saturated * and so reject the task. */ int c = ctl.get(); if (workerCountOf(c) < corePoolSize) { if (addWorker(command, true)) return; c = ctl.get(); } if (isRunning(c) && workQueue.offer(command)) { int recheck = ctl.get(); if (! isRunning(recheck) && remove(command)) reject(command); else if (workerCountOf(recheck) == 0) addWorker(null, false); } else if (!addWorker(command, false)) reject(command); }这部分代码就是前面提到的线程池执行机制，进行核心线程数或最大线程数的判断等，注意一个addWorker方法，下面截取方法的部分
boolean workerStarted = false; boolean workerAdded = false; Worker w = null; try { w = new Worker(firstTask); final Thread t = w.thread; if (t != null) { final ReentrantLock mainLock = this.mainLock; mainLock.lock(); try { // Recheck while holding lock. // Back out on ThreadFactory failure or if // shut down before lock acquired. int rs = runStateOf(ctl.get()); if (rs < SHUTDOWN || (rs == SHUTDOWN && firstTask == null)) { if (t.isAlive()) // precheck that t is startable throw new IllegalThreadStateException(); workers.add(w); int s = workers.size(); if (s > largestPoolSize) largestPoolSize = s; workerAdded = true; } } finally { mainLock.unlock(); } if (workerAdded) { t.start(); workerStarted = true; } } } finally { if (! workerStarted) addWorkerFailed(w); }将我们传入的runnable对象包装成一个worker对象，接下看看这个worker类
看到worker实现了Runnable接口，自然重写了run()方法，
看到构造方法，根据本对象(Worker)获取到了线程
有两个我框起来的成员属性，分别是Thread和Runnale对象，addWorker()方法中有一句t.start()，线程启动，所以自然会去执行worker中的run()方法，而run()方法又调用了runWorker()方法
看到不断获取任务，如果获取到就进行执行，注意执行是task.run()，也就是说只是对一个Runnable对象里的一个方法的调用，而不是像平常使用线程编程时的start()，直接调用run()方法JVM是不会帮我们去生成新线程的，就像和调用普通方法一样，所以一个线程始终都会在whlie循环的逻辑中不断的被重复利用，然后去取Worker对象的firstTask或者通过getTask方法从工作队列中获取待执行的任务，再直接调用Runnable类型的run方法执行任务。
以上是一点对线程池的总结，欢迎大家交流指正。
