一、线程池优点
1、线程在创建和销毁时是非常耗费资源的，使用线程池可以减少创建和销毁线程的次数，每个工作线程都可以重复使用。
2、可以根据系统的承受能力，调整线程池中工作线程的数量，防止因为消耗过多内存导致服务器崩溃。
二、线程池创建
java.uitl.concurrent.ThreadPoolExecutor类是线程池中最核心的一个类，因此如果要透彻地了解Java中的线程池，必须先了解这个类。下面我们来看一下ThreadPoolExecutor类的具体实现源码。
public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler) { if (corePoolSize < 0 || maximumPoolSize <= 0 || maximumPoolSize < corePoolSize || keepAliveTime < 0) //如果配置的参数不合法，则抛出异常 throw new IllegalArgumentException(); if (workQueue == null || threadFactory == null || handler == null) throw new NullPointerException(); this.acc = System.getSecurityManager() == null ? null : AccessController.getContext(); this.corePoolSize = corePoolSize; this.maximumPoolSize = maximumPoolSize; this.workQueue = workQueue; this.keepAliveTime = unit.toNanos(keepAliveTime); this.threadFactory = threadFactory; this.handler = handler; }
其中参数分别为：
corePoolSize：线程池核心线程数量。
在创建了线程池后，默认情况下，线程池中并没有任何线程，而是等待有任务到来才创建线程去执行任务，
除非调用了prestartAllCoreThreads()或者prestartCoreThread()方法
prestartAllCoreThreads()：预先创建所有核心线程
prestartCoreThread()：预先创建一个核心线程
maximumPoolSize:线程池最大线程数量
keepAliverTime:当活跃线程数大于核心线程数时，空闲的多余线程最大存活时间。
默认情况下，只有当线程池中的线程数大于corePoolSize时，keepAliveTime才会起作用，直到线程池中的线程数不大于corePoolSize.
如果调用了allowCoreThreadTimeOut(boolean)方法，在线程池中的线程数不大于corePoolSize时，keepAliveTime参数也会起作用，直到线程池中的线程数为0
unit：存活时间的单位
workQueue：存放任务的队列
threadFactory：线程工厂，一般使用默认即可
handler：超出线程范围和队列容量的任务的处理程序（拒接策略）
三、任务处理流程
提交一个任务到线程池中，线程池的处理流程如下：
1、判断线程池里的核心线程是否都在执行任务，如果不是（核心线程空闲或者还有核心线程没有被创建）则创建一个新的工作线程来执行任务。如果核心线程都在执行任务，则进入下个流程。
2、线程池判断工作队列是否已满，如果工作队列没有满，则将新提交的任务存储在这个工作队列里。如果工作队列满了，则进入下个流程。
3、判断线程池里的线程是否达到最大线程数，如果没有，则创建一个新的工作线程来执行任务。如果已经达到最大线程数，则交给拒绝策略来处理这个任务。
四、任务缓存队列及排队策略
在前面我们多次提到了任务缓存队列，即workQueue，它用来存放等待执行的任务。
workQueue的类型为BlockingQueue<Runnable>，通常可以取下面三种类型：
1）ArrayBlockingQueue：基于数组的先进先出队列，此队列创建时必须指定大小；
2）LinkedBlockingQueue：基于链表的先进先出队列，如果创建时没有指定此队列大小，则默认为Integer.MAX_VALUE；
3）synchronousQueue：这个队列比较特殊，它不会保存提交的任务，而是将直接新建一个线程来执行新来的任务。
五、任务拒绝策略
当线程池的任务缓存队列已满并且线程池中的线程数目达到maximumPoolSize，如果还有任务到来就会采取任务拒绝策略，通常有以下四种策略：
ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。
ThreadPoolExecutor.DiscardPolicy：也是丢弃任务，但是不抛出异常。
ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程）
ThreadPoolExecutor.CallerRunsPolicy：由调用线程处理该任务
六、线程池的关闭
ThreadPoolExecutor提供了两个方法，用于线程池的关闭，分别是shutdown()和shutdownNow()，其中：
shutdown()：不会立即终止线程池，而是要等所有任务缓存队列中的任务都执行完后才终止，但再也不会接受新的任务
shutdownNow()：立即终止线程池，并尝试打断正在执行的任务，并且清空任务缓存队列，返回尚未执行的任务
七、线程池实现原理
1、线程池重要成员变量
（1）AtomicInteger ctl
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
ctl代表了ThreadPoolExecutor中的控制状态，它是一个复合类型的成员变量，是一个原子整数，借助高低位包装了两个概念：
workerCount：线程池中当前活动的线程数量，占据ctl的低29位；
runState：线程池运行状态，占据ctl的高3位，有RUNNING、SHUTDOWN、STOP、TIDYING、TERMINATED五种状态。
（2）COUNT_BITS和CAPACITY
由于线程池通过workerCount表示当前活动的线程数量，它占据ctl的低29位，这样，每当活跃线程数增加或减少时，ctl直接做相应数目的增减即可，十分方便。而ThreadPoolExecutor中COUNT_BITS就代表了workerCount所占的位数，定义如下：
private static final int COUNT_BITS = Integer.SIZE - 3;
在Java中，一个int占据32位，因此Integer.SIZE = 32，因此COUNT_BITS的大小就是29。另外，既然workerCount代表了线程池中当前活动的线程数量，那么它肯定有个上下限阈值，下限很明显就是0，上限是ThreadPoolExecutor中CAPACITY值，它是ThreadPoolExecutor中理论上的最大活跃线程数，其定义如下：
private static final int CAPACITY = (1 << COUNT_BITS) - 1;
运算过程为1左移29位，也就是00000000 00000000 00000000 00000001 --> 001 0000 00000000 00000000 00000000，再减去1的话，就是 000 11111 11111111 11111111 11111111即CAPACITY的值，前三位代表线程池运行状态runState，所以这里workerCount的理论最大值就应该是29个1，即536870911；
由于workerCount作为其中一个部分复合在AtomicInteger ctl的低29位中，那么ThreadPoolExecutor理应提供从AtomicInteger ctl中解析出workerCount的方法：
private static int workerCountOf(int c) { return c & CAPACITY; }
计算逻辑很简单，入参是ctl的值(ctl.get())，即高3位为线程池运行状态runState，低29位为线程池中当前活动的线程数量workerCount，将其与CAPACITY进行与操作&，也就是与000 11111 11111111 11111111 11111111进行与操作，c的前三位通过与000进行与操作，无论c前三位为何值，最终都会变成000，也就是舍弃前三位的值，而c的低29位与29个1进行与操作，c的低29位还是会保持原值，这样就从AtomicInteger ctl中解析出了workerCount的值。
（3）runState
线程池定义了几个static final变量表示线程池的各个状态：
// runState is stored in the high-order bits private static final int RUNNING = -1 << COUNT_BITS; //-1在Java底层是由32个1表示的，左移29位的话，即111 00000 00000000 00000000 00000000，也就是低29位全部为0，高3位全部为1的话，表示RUNNING状态，即-536870912. private static final int SHUTDOWN = 0 << COUNT_BITS; //0在Java底层是由32个0表示的，无论左移多少位，还是32个0，即000 00000 00000000 00000000 00000000，也就是低29位全部为0，高3位全部为0的话，表示SHUTDOWN状态，即0； private static final int STOP = 1 << COUNT_BITS; //1在Java底层是由前面的31个0和1个1组成的，左移29位的话，即001 00000 00000000 00000000 00000000，也就是低29位全部为0，高3位为001的话，表示STOP状态，即536870912； private static final int TIDYING = 2 << COUNT_BITS; //2在Java底层是由前面的30个0和1个10组成的，左移29位的话，即010 00000 00000000 00000000 00000000，也就是低29位全部为0，高3位为010的话，表示TIDYING状态，即1073741824； private static final int TERMINATED = 3 << COUNT_BITS; //2在Java底层是由前面的30个0和1个11组成的，左移29位的话，即011 00000 00000000 00000000 00000000，也就是低29位全部为0，高3位为011的话，表示TERMINATED状态，即1610612736；
当创建线程池后，初始时，线程池处于RUNNING状态；
如果调用了shutdown()方法，则线程池处于SHUTDOWN状态，此时线程池不能够接受新的任务，它会等待所有任务执行完毕；
如果调用了shutdownNow()方法，则线程池处于STOP状态，此时线程池不能接受新的任务，并且会去尝试终止正在执行的任务；
当线程池处于SHUTDOWN或STOP状态，并且所有工作线程已经销毁，任务缓存队列已经清空或执行结束后，线程池被设置为TERMINATED状态。
线程池获取运行状态代码如下：
private static int runStateOf(int c) { return c & ~CAPACITY; }
~是按位取反的意思，CAPACITY表示的是高位的3个0，和低位的29个1，而~CAPACITY则表示高位的3个1，低位的29个0即111 00000 00000000 00000000 00000000，然后再与入参c执行按位与操作，即高3位保持原样，低29位全部设置为0，也就获取了线程池的运行状态runState。
最后看下ctl的ctlOf定义如下：
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0)); private static int ctlOf(int rs, int wc) { return rs | wc; }
即RUNNING状态值和0做或运算：传入的rs表示线程池运行状态runState，其是高3位有值，低29位全部为0的int，而wc则代表线程池中有效线程的数量workerCount，其为高3位全部为0，而低29位有值得int，将runState和workerCount做或操作|处理，即用runState的高3位，workerCount的低29位填充的数字，而默认传入的runState、workerCount分别为RUNNING和0。
2、线程池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. * 1、如果少于corePoolSize数量的线程正在运行，尝试利用给定的Runnable实例command创建一个新的线程作为它的第一个任务来执行。 * addWorker()方法的调用会对线程池运行状态runState、线程数量workerCount进行原子性检测，返回值为启动新线程结果。 * * 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. * 2、如果一个任务可以成功地进入队列，然后我们还需要再次检查（即双份检查）自从进入这个方法后，我们是否应该添加一个线程 * （因为自从上一次检查以来可能存在死亡情况）， * 所以我们重新检查状态，如果有必要的话，即线程池已停止，回滚之前的入队操作，或者在没有线程时启动一个新线程。 * * 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. * 3、如果我们不能入列一个任务，那么我们尝试添加一个新线程。 * 如果添加失败，我们知道线程池可能已被关闭或者数量饱和，所以我们会拒绝这个任务。 */ // 获取ctl的值c int c = ctl.get(); // 如果c中有效线程数目小于corePoolSize大小，尝试创建新的core线程处理任务command： // 从c中获取有效线程数目调用的是workerCountOf()方法， // 添加新的core线程处理任务command调用的是addWorker()方法， // 线程数的判断利用corePoolSize作为边界约束条件 // 方法返回值是标志添加worker是否成功的标志位，ture表示成功，false表示失败， // 如果为true，则直接返回，否则重新获取ctl的值c if (workerCountOf(c) < corePoolSize) { if (addWorker(command, true)) return; // 添加work线程失败则再次获取ctl的值 c = ctl.get(); } // 根据c判断当前线程池的状态是否为RUNNING状态，即既可以接受新任务，又会处理队列任务的状态， // 并且通过offer()方法，尝试将commond添加到队列workQueue中 // BlockingQueue的offer()方法表示如果可能的话，将参数对象加到BlockingQueue里， // 即如果BlockingQueue可以容纳，则返回true，否则返回false if (isRunning(c) && workQueue.offer(command)) { // 如果当前线程池处于RUNNING状态，且workQueue能够容纳command，并添加成功的话， // 再次获取ctl的值recheck， int recheck = ctl.get(); // 如果当前线程池的状态不是RUNNING，并且从队列workQueue移除command成功的话， // 调用reject()方法拒绝任务command， if (! isRunning(recheck) && remove(command)) reject(command); // 否则如果当前工作线程woker数目为0，尝试添加新的worker线程，但是不携带任务 else if (workerCountOf(recheck) == 0) addWorker(null, false); } // 如果尝试添加新的worker线程处理任务command失败， // 调用reject()方法拒绝任务command，线程数的判断利用maximumPoolSize作为边界约束条件 else if (!addWorker(command, false)) reject(command); }
其中addWorker方法传入当前任务，并尝试创建一个线程去执行任务：
private boolean addWorker(Runnable firstTask, boolean core) { retry: for (;;) { int c = ctl.get(); int rs = runStateOf(c); // Check if queue empty only if necessary. if (rs >= SHUTDOWN && ! (rs == SHUTDOWN && firstTask == null && ! workQueue.isEmpty())) return false; for (;;) { int wc = workerCountOf(c);//获取线程数量 if (wc >= CAPACITY || wc >= (core ? corePoolSize : maximumPoolSize))//线程数量未达到最大值 return false; if (compareAndIncrementWorkerCount(c))//原子操作增加线程数量 break retry; c = ctl.get(); // Re-read ctl if (runStateOf(c) != rs) continue retry; // else CAS failed due to workerCount change; retry inner loop } } 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); } return workerStarted; }
其中w = new Worker(firstTask);final Thread t = w.thread;表示创建一个新的线程，其中worker的构造函数如下：
Worker(Runnable firstTask) { setState(-1); // inhibit interrupts until runWorker this.firstTask = firstTask; this.thread = getThreadFactory().newThread(this); }
在创建Thread时把当前worker作为runnable入参传给了当前线程，因此在执行t.start()方法是，会执行当前worker的run()方法：
public void run() { runWorker(this); }
final void runWorker(Worker w) { Thread wt = Thread.currentThread(); Runnable task = w.firstTask; w.firstTask = null; w.unlock(); // allow interrupts boolean completedAbruptly = true; try { while (task != null || (task = getTask()) != null) { w.lock(); // If pool is stopping, ensure thread is interrupted; // if not, ensure thread is not interrupted. This // requires a recheck in second case to deal with // shutdownNow race while clearing interrupt if ((runStateAtLeast(ctl.get(), STOP) || (Thread.interrupted() && runStateAtLeast(ctl.get(), STOP))) && !wt.isInterrupted()) wt.interrupt(); try { beforeExecute(wt, task); Throwable thrown = null; try { task.run(); } catch (RuntimeException x) { thrown = x; throw x; } catch (Error x) { thrown = x; throw x; } catch (Throwable x) { thrown = x; throw new Error(x); } finally { afterExecute(task, thrown); } } finally { task = null; w.completedTasks++; w.unlock(); } } completedAbruptly = false; } finally { processWorkerExit(w, completedAbruptly); } }
在执行worker的方法中，首先会执行firstTask，firstTask执行完之后会执行getTask()通过自旋从阻塞队列中获取任务：
private Runnable getTask() { boolean timedOut = false; // Did the last poll() time out? for (;;) {//自旋 int c = ctl.get();//获取ctl int rs = runStateOf(c);//获取线程池状态 // Check if queue empty only if necessary. if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) { decrementWorkerCount(); return null; } int wc = workerCountOf(c);//获取线程数量 // Are workers subject to culling? //是否设置了核心线程超时或者线程数量是否大于核心线程数 boolean timed = allowCoreThreadTimeOut || wc > corePoolSize; //如果线程数量大于最大线程数或者设置了核心线程超时 if ((wc > maximumPoolSize || (timed && timedOut)) && (wc > 1 || workQueue.isEmpty())) { if (compareAndDecrementWorkerCount(c)) return null; continue; } try { //获取一个任务 Runnable r = timed ? workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) : workQueue.take(); if (r != null) return r; timedOut = true; } catch (InterruptedException retry) { timedOut = false; } } }
参考：
1、Java并发编程：线程池的使用 https://www.cnblogs.com/dolphin0520/p/3932921.html
2、ThreadPoolExecutor源码分析（一）：重要成员变量 https://blog.csdn.net/lipeng_bigdata/article/details/51232266
https://blog.csdn.net/lipeng_bigdata/article/details/51243348
3、与运算(&)、或运算(|)等：https://blog.csdn.net/xiaopihaierletian/article/details/78162863