多线程进阶之线程池
为什么要创建线程池
在不使用线程池的情景当中，每次任务来临了就创建一个线程去处理，任务结束了就撤销线程。这种方式造成了极大的开销。且不易与维护。通过线程池完成了
1：线程的复用。重用线程池中的线程，避免因为线程的创建和销毁所带来的性能开销。
2：能有效控制线程池的最大并发数，避免大量线程之间因互相抢夺系统资源而导致的阻塞现象。
3：能够对线程进行简单的管理，并提供定时执行以及指向间隔循环执行等功能。
。
线程池的创建方法
相关类关系图
先看和线程池有关的类之间的关系图：
通过UML图可以看出，创建线程池有两种方式：
通过工具类Excutors来创建
其为我们提供了4种在不同场景下的线程池供我们使用：
（1） FixedThreadPool
一个线程池固定的池子，其具备核心线程响应外界的请求。没有超时机制。一次性进行一次代价高昂的线程分配。
（2） SingleThreadExecutor
具备一个主线程，其他线程都在主线程的管理下进行。有效解决了同步问题
（3） ScheduledThreadPool
用来执行定时或者固定周期的任务，核心线程数目是固定的
（4） CachedThreadPool
其最大线程数是Integer.max()，线程执行完就销毁，适合任务量大，时间短的线程.具备超时机制，当没有任务的时候，就回收所有线程，不占用系统资源。适合处理大规模，但耗时较少的任务.
代码实例：
ExecutorService eService =Executors.newCachedThreadPool();
eService.execute(new Runnable() {
@Override
public void run() {
//具体执行任务
}
});通过ThreadPoolExecuter来创建（推荐）
在阿里的规约插件P3c中，明确表示不用工具类来创建线程，旨在让程序员自己构造线程池的具体参数
代码实例：
ThreadPoolExecutor te =new ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue)第一个参是核心线程数，第二个是最大线程数，第三个是核心线程的轮询获取任务的最大等待时间，最后一个是程序员自己设计的线程等待队列。
执行新的任务的两种方式
execute
返回值为空无法知道当前线程的执行状态
submit
返回的是一个叫做Future的对象。在源码中，submit也是调用的execute.
Future表示能异步计算返回的结果，当使用thread和runable的时候，是得不到返回值的，使用callable时候，在实现接口位置需要implents callable< String>，即返回一个用future< Sring>表示的返回结果，用来显示多线程的输出。下面代码的线程返回的是一个future< String>的对象
ExecutorService eService =Executors.newCachedThreadPool();
eService.submit(new Callable<String>(){
@Override
public String call() throws Exception {
// TODO Auto-generated method stub
return null;
}
});线程池原理
线程池的状态
先介绍几个线程池当中的重要组件概念：
核心线程（corePool）：线程池最终执行任务的角色肯定还是线程，同时我们也会限制线程的数量，所以我们可以这样理解核心线程，有新任务提交时，首先检查核心线程数，如果核心线程都在工作，而且数量也已经达到最大核心线程数，则不会继续新建核心线程，而会将任务放入等待队列。
**等待队列 (workQueue)：**等待队列用于存储当核心线程都在忙时，继续新增的任务，核心线程在执行完当前任务后，也会去等待队列拉取任务继续执行，这个队列一般是一个线程安全的阻塞队列，它的容量也可以由开发者根据业务来定制。
**非核心线程：**当等待队列满了，如果当前线程数没有超过最大线程数，则会新建线程执行任务，那么核心线程和非核心线程到底有什么区别呢？说出来你可能不信，本质上它们没有什么区别，创建出来的线程也根本没有标识去区分它们是核心还是非核心的，线程池只会去判断已有的线程数（包括核心和非核心）去跟核心线程数和最大线程数比较，来决定下一步的策略。
**线程活动保持时间 (keepAliveTime)：**线程空闲下来之后，保持存货的持续时间，超过这个时间还没有任务执行，该工作线程结束。
**饱和策略 (RejectedExecutionHandler)：**当等待队列已满，线程数也达到最大线程数时，线程池会根据饱和策略来执行后续操作，默认的策略是抛弃要加入的任务。
当一个任务来到线程池之后，其被执行的逻辑如下图
（1）先判断核心池满了没有，如果没有满，创建新核心线程执行任务，如果满了，进入（2）
（2）线程进入等待队列，这个队列是核心线程每次拉取任务的地方（误区：核心线程数目+等待队列+非核心线程数≠最大线程数。最大线程数和等待队列的数目都是开发者自己设计的）。如果等待队列没满。加入等待队列。
（3）如果线程等待队列也满了，则判断当前线程数是否达到最大线程数。（当前线程数=核心+非核心）超过了最大线程数，执行饱和策略，默认是拒绝(reject)（抛出异常）
（4）如果没有达到最大线程数，则新建非核心线程，从队列中取线程。
注意poll方法和take方法：
这个就是blockQueue里面的api了；这里简单的说一下作用
poll方法会从队列里面取runnable，如果取不到会把当前线程挂起（阻塞）超过给定的时间仍然取不到就会返回一个null；
take方法从队列里面取runnable，如果取不到会一直挂起，直到取到为止；
如果超时无法从队列拿到Runnable会被标记超时（timeOut = true），然后循判断超时如果队列中还有worker或者队列为空则返回null生命周期结束。
线程池就是通过阻塞队列的这两个方法来控制超时以及线程的生命周期的。
线程池源码探析之为什么能实现线程复用
先来看一下执行任务的excute方法的源码：
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
//第一步，获取ctl
int c = ctl.get();
//检查当前线程数是否达到核心线程数的限制，注意线程本身是不区分核心还是非核心，后面会进一步验证
if (workerCountOf(c) < corePoolSize) {
//如果核心线程数未达到，会直接添加一个核心线程，也就是说在线程池刚启动预热阶段，
//提交任务后，会优先启动核心线程处理
if (addWorker(command, true))
return;
//如果添加任务失败，刷新ctl，进入下一步
c = ctl.get();
}
//检查线程池是否是运行状态，然后将任务添加到等待队列，注意offer是不会阻塞的
if (isRunning(c) && workQueue.offer(command)) {
//任务成功添加到等待队列，再次刷新ctl
int recheck = ctl.get();
//如果线程池不是运行状态，则将刚添加的任务从队列移除并执行拒绝策略
if (! isRunning(recheck) && remove(command))
reject(command);
//判断当前线程数量，如果线程数量为0，则添加一个非核心线程，并且不指定首次执行任务
else if (workerCountOf(recheck) == 0)
addWorker(null, false);
}
//添加非核心线程，指定首次执行任务，如果添加失败，执行异常策略
else if (!addWorker(command, false))
reject(command);
}注意CTL是原子类，来保证当前线程数的安全。避免了使用重量级别的锁。
其中一个重要的添加线程的方法是addworker（）其返回类型是布尔型。即新加线程是否成功。
再深入这个方法：
private boolean addWorker(Runnable firstTask, boolean core) {
//相当于goto，虽然不建议滥用，但这里使用又觉得没一点问题
retry:
for (;;) {
int c = ctl.get();
int rs = runStateOf(c);
//如果线程池的状态到了SHUTDOWN或者之上的状态时候，只有一种情况还需要继续添加线程，
//那就是线程池已经SHUTDOWN，但是队列中还有任务在排队,而且不接受新任务（所以firstTask必须为null）
//这里还继续添加线程的初衷是，加快执行等待队列中的任务，尽快让线程池关闭
// Check if queue empty only if necessary.
if (rs >= SHUTDOWN &&
! (rs == SHUTDOWN &&
firstTask == null &&
! workQueue.isEmpty()))
return false;
for (;;) {
int wc = workerCountOf(c);
//传入的core的参数，唯一用到的地方，如果线程数超过理论最大容量，如果core是true跟最大核心线程数比较，否则跟最大线程数比较
if (wc >= CAPACITY ||
wc >= (core ? corePoolSize : maximumPoolSize))
return false;
//通过CAS自旋，增加线程数+1，增加成功跳出双层循环，继续往下执行
if (compareAndIncrementWorkerCount(c))
break retry;
//检测当前线程状态如果发生了变化，则继续回到retry，重新开始循环
c = ctl.get(); // Re-read ctl
if (runStateOf(c) != rs)
continue retry;
// else CAS failed due to workerCount change; retry inner loop
}
}
//走到这里，说明我们已经成功的将线程数+1了，但是真正的线程还没有被添加
boolean workerStarted = false;
boolean workerAdded = false;
Worker w = null;
try {
//添加线程，Worker是继承了AQS，实现了Runnable接口的包装类
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());
//检查线程状态，还是跟之前一样，只有当线程池处于RUNNING，或者处于SHUTDOWN并且firstTask==null的时候，这时候创建Worker来加速处理队列中的任务
if (rs < SHUTDOWN ||
(rs == SHUTDOWN && firstTask == null)) {
//线程只能被start一次
if (t.isAlive()) // precheck that t is startable
throw new IllegalThreadStateException();
//workers是一个HashSet，添加我们新增的Worker
workers.add(w);
int s = workers.size();
if (s > largestPoolSize)
largestPoolSize = s;
workerAdded = true;
}
} finally {
mainLock.unlock();
}
if (workerAdded) {
//启动Worker
t.start();
workerStarted = true;
}
}
} finally {
if (! workerStarted)
addWorkerFailed(w);
}
return workerStarted;
}可以看到，在调用start 方法后，启动了线程。将addWorker方法返回值设为了true。
到这里为止这一大块代码解决的仅仅是加入一个线程能否成功（是否满足上面那个调度图可以运行任务的条件）真正的线程复用在work(内部封装了真正的任务)Start方法（即worker的run方法里面）
上源码：
/Worker的run方法调用的是ThreadPoolExecutor的runWorker方法
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 {
//如果task不是null，或者去队列中取任务，注意这里会阻塞，后面会分析getTask方法
while (task != null || (task = getTask()) != null) {
//这个lock在这里是为了如果线程被中断，那么会抛出InterruptedException，而退出循环，结束线程
w.lock();
//判断线程是否需要中断
if ((runStateAtLeast(ctl.get(), STOP) ||
(Thread.interrupted() &&
runStateAtLeast(ctl.get(), STOP))) &&
!wt.isInterrupted())
wt.interrupt();
try {
//任务开始执行前的hook方法
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 {
任务开始执行后的hook方法
afterExecute(task, thrown);
}
} finally {
task = null;
w.completedTasks++;
w.unlock();
}
}
completedAbruptly = false;
} finally {
//Worker退出
processWorkerExit(w, completedAbruptly);
}
}
private Runnable getTask() {
boolean timedOut = false; // Did the last poll() time out?
for (;;) {
int c = ctl.get();
int rs = runStateOf(c);
// Check if queue empty only if necessary.
//检查线程池的状态，如果已经是STOP及以上的状态，或者已经SHUTDOWN，队列也是空的时候，直接return null，并将Worker数量-1
if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
decrementWorkerCount();
return null;
}
int wc = workerCountOf(c);
// 注意这里的allowCoreThreadTimeOut参数，字面意思是否允许核心线程超时，即如果我们设置为false，那么只有当线程数wc大于corePoolSize的时候才会超时
//更直接的意思就是，如果设置allowCoreThreadTimeOut为false，那么线程池在达到corePoolSize个工作线程之前，不会让闲置的工作线程退出
boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
//确认超时，将Worker数-1，然后返回
if ((wc > maximumPoolSize || (timed && timedOut))
&& (wc > 1 || workQueue.isEmpty())) {
if (compareAndDecrementWorkerCount(c))
return null;
continue;
}
try {
//从队列中取任务，根据timed选择是有时间期限的等待还是无时间期限的等待
//看之前我对take和poll的说明
//复用的关键
Runnable r = timed ?
workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
workQueue.take();
if (r != null)
return r;
timedOut = true;
} catch (InterruptedException retry) {
timedOut = false;
}
}
}复用的关键在getTask这个类中
其最外层是一层大的循环。
线程池中的线程在循环中尝试取任务执行，这一步会被阻塞
如果设置了allowCoreThreadTimeOut为true，会调用poll则线程池中的所有线程都会在keepAliveTime时间超时后还未取到任务而退出。或者线程池已经STOP，那么所有线程都会被中断，然后退出。
如果没有设置，会调用take，一直阻塞，通过这种方式，从队列中拿取了任务执行。完成了线程的复用。
（把原来的RUN给屏蔽掉，自用一个RUN来实现）这就是为什么线程池能服用。
