1. 线程池介绍
Java构建线程的方式
- new Thread
- new Runnable
- new Callable
为了避免频繁创建和销毁线程造成不必要的性能，一般在使用线程时，会采用线程池
核心线程数设置的方案：
线程池的工作流程简述
执行execute添加任务，线程池创建工作线程，执行任务，再次拉取工作队列任务，直到工作队列没有任务，阻塞工作线程。
2.线程池的核心参数
核心线程数（int corePoolSize）
线程池维护的最小线程数量，核心线程创建后不会被回收（注意：设置allowCoreThreadTimeout=true后，空闲的核心线程超过存活时间也会被回收）。
最大线程数（int maximumPoolSize）
线程池允许创建的最大线程数量。当添加一个任务时，核心线程数已满，线程池还没达到最大线程数，并且没有空闲线程，工作队列已满的情况下，创建一个新线程并执行。
空闲线程存活时间（long keepAliveTime）
当一个可被回收的线程的空闲时间大于keepAliveTime，就会被回收。 两种情况：
- 设置allowCoreThreadTimeout=true的核心线程
- 大于核心线程数的线程（非核心线程）。
时间单位（TimeUnit unit）
keepAliveTime的时间单位
工作队列（BlockingQueue<Runnable> workQueue）
等待执行的任务队列（阻塞队列）：当提交的任务数超过核心线程数大小后，再提交的任务就存放在工作队列，任务调度时再从队列中取出任务。
- BlockingQueue有多种实现，线程池中需要注意有界队列和无界队列的使用
线程工厂(ThreadFactory threadFactory)
创建线程的工厂，可以设定线程名、线程编号等。Executors类提供了默认的线程工厂（DefaultThreadFactory）
拒绝策略（RejectedExecutionHandler handler）
当线程池线程数已满，并且工作队列达到限制，新提交的任务使用拒绝策略处理。可以自定义拒绝策略，拒绝策略需要实现RejectedExecutionHandler接口。
JDK提供的拒绝策略有四种：
- AbortPolicy：丢弃任务并抛出RejectedExecutionException异常。
- DiscardPolicy：丢弃任务，但是不抛出异常。可能导致无法发现系统的异常状态。
- DiscardOldestPolicy：丢弃队列最前面的任务，然后重新提交被拒绝的任务。
- CallerRunsPolicy：由调用线程处理该任务。
ThreadPoolExecutor中默认使用AbortPolicy
3.ThreadPoolExecutor源码分析
3.1 ThreadPoolExecutor核心属性
// AtomicInteger,就是一个原子性的int，写操作用CAS实现
// ctl维护这线程池的2个核心内容：
// 1：线程池状态（高3位，维护着线程池状态）
// 2：工作线程数量（核心线程+非核心线程，低29位，维护着工作线程个数）
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
// COUNT_BITS=29
private static final int COUNT_BITS = Integer.SIZE - 3;
// 工作线程的最大个数
// 00100000 00000000 00000000 00000000 - 1
// 000111111111111111111111111111111
private static final int CAPACITY = (1 << COUNT_BITS) - 1;
private static final int RUNNING = -1 << COUNT_BITS;
private static final int SHUTDOWN = 0 << COUNT_BITS;
private static final int STOP = 1 << COUNT_BITS;
private static final int TIDYING = 2 << COUNT_BITS;
private static final int TERMINATED = 3 << COUNT_BITS;
// 拿到线程池状态
// 011...
// 111...
private static int runStateOf(int c) { return c & ~CAPACITY; }
// 拿到工作线程个数
// ...0000000111111
// ...1111111111111
private static int workerCountOf(int c) { return c & CAPACITY; }
线程池的几种状态
3.2 execute方法-提交任务
通过execute方法，可以看到线程池处理任务的整体执行流程
public void execute(Runnable command) {
// 不能添加null
if (command == null)
throw new NullPointerException();
// 拿到ctl
int c = ctl.get();
// 通过ctl获取当前工作线程个数
if (workerCountOf(c) < corePoolSize) {
// true：代表是核心线程，false：代表是非核心线程
if (addWorker(command, true))
// 如果添加核心线程成功，return结束掉
return;
// 如果添加失败，重新获取ctl
c = ctl.get();
}
// 核心线程数已经到了最大值、添加时，线程池状态变为SHUTDOWN/STOP
// 判断线程池是否是运行状态 && 添加任务到工作队列
if (isRunning(c) && workQueue.offer(command)) {
// 再次获取ctl的值
int recheck = ctl.get();
// 再次判断线程池状态。 DCL
// 如果状态不是RUNNING，把任务从工作队列移除。
if (! isRunning(recheck) && remove(command))
// 走一波拒绝策略。
reject(command);
// 线程池状态是RUNNING。
// 判断工作线程数是否是0个。
// 可以将核心线程设置为0，所有工作线程都是非核心线程。
// 核心线程也可以通过keepAlived超时被销毁，所以如果恰巧核心线程被销毁，也会出现当前效果
else if (workerCountOf(recheck) == 0)
// 添加空任务的非核心线程去处理工作队列中的任务
addWorker(null, false);
}
// 可能工作队列中的任务存满了，没添加进去，到这就要添加非核心线程去处理任务
else if (!addWorker(command, false))
// 执行拒绝策略！
reject(command);
}
3.3 addWorker方法-添加工作线程
core表示是否为核心线程
private boolean addWorker(Runnable firstTask, boolean core) {
retry:
for (;;) {
// 获取ctl
int c = ctl.get();
int rs = runStateOf(c);
// 判断线程池状态
if (rs >= SHUTDOWN &&
// 判断如果线程池的状态为SHUTDOWN，还要处理工作队列中的任务
// 如果你添加工作线程的方式，是任务的非核心线程，并且工作队列还有任务
! (rs == SHUTDOWN && firstTask == null && ! workQueue.isEmpty()))
return false;
// 判断工作线程个数
for (;;) {
// 拿到工作线程个数
int wc = workerCountOf(c);
// 判断1：工作线程是否已经 == 工作线程最大个数
// 判断2-true判断：判断是核心线程么？如果是判断是否超过核心线程个数
// 判断2-false判断：如果是非核心线程，查看是否超过设置的最大线程数
if (wc >= CAPACITY || wc >= (core ? corePoolSize : maximumPoolSize))
return false;
// 对工作线程进行 + 1操作
if (compareAndIncrementWorkerCount(c))
// +1成功，跳出外层循环，执行添加工作线程的业务
// 以CAS方式，对ctl+1，多线程并发操作，只有会有一个成功
break retry;
// 重新拿ctl，
c = ctl.get();
// 判断线程池状态是否有变化
if (runStateOf(c) != rs)
continue retry;
}
}
// 添加工作线程的业务
// 工作线程启动了吗？
boolean workerStarted = false;
// 工作线程添加了吗？
boolean workerAdded = false;
// Worker就是工作线程
Worker w = null;
try {
// 创建工作线程，将任务传到Worker中
w = new Worker(firstTask);
final Thread t = w.thread;
// 只有你写的线程工厂返回的是null，这里才会为null
if (t != null) {
// 获取锁资源
final ReentrantLock mainLock = this.mainLock;
// 加锁。 因为我要在启动这个工作线程时，避免线程池状态发生变化，加锁。
mainLock.lock();
try {
// 重新获取ctl，拿到线程池状态
int rs = runStateOf(ctl.get());
// DCL i think you know~~~
if (rs < SHUTDOWN ||
(rs == SHUTDOWN && firstTask == null)) {
// 判断Worker中的thread是否已经启动了，一般不会启动，除非你在线程工厂把他启动了
if (t.isAlive())
throw new IllegalThreadStateException();
// 将工作线程存储到hashSet中
workers.add(w);
// 获取工作线程个数，判断是否需要修改最大工作线程数记录。
int s = workers.size();
if (s > largestPoolSize)
largestPoolSize = s;
// 工作线程添加成功 0
workerAdded = true;
}
} finally {
mainLock.unlock();
}
// 如果添加成功
if (workerAdded) {
// 启动工作线程
t.start();
// 设置标识为true
workerStarted = true;
}
}
} finally {
// 如果工作线程启动失败
if (! workerStarted)
addWorkerFailed(w);
}
return workerStarted;
}
// 如果添加工作线程失败，执行
private void addWorkerFailed(Worker w) {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
// 说明worker可能存放到了workers的hashSet中。
if (w != null)
// 移除！
workers.remove(w);
// 减掉workerCount的数值 -1
decrementWorkerCount();
// 尝试干掉自己
tryTerminate();
} finally {
mainLock.unlock();
}
}
3.4 runWorker方法-执行任务
final void runWorker(Worker w) {
// 拿到当前线程对象
Thread wt = Thread.currentThread();
// 拿到worker中存放的Runnable
Runnable task = w.firstTask;
// 将worker中的任务清空
w.firstTask = null;
// 揍是一个标识
boolean completedAbruptly = true;
try {
// 如果Worker自身携带任务，直接执行
// 如果Worker携带的是null，通过getTask去工作队列获取任务
while (task != null || (task = getTask()) != null) {
w.lock();
// 判断线程池状态是否大于等于STOP，如果是要中断当前线程
if ((runStateAtLeast(ctl.get(), STOP) ||
// 中断当前线程（DCL）
(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);
}
}
3.5 getTask方法-获取任务
private Runnable getTask() {
// 超时-false
boolean timedOut = false; // Did the last poll() time out?
for (;;) {
// 获取ctl
int c = ctl.get();
// 拿到线程池状态
int rs = runStateOf(c);
// 线程池状态判断
// 如果线程池状态为SHUTDOWN && 工作队列为空
// 如果线程池状态为STOP
if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
// 对工作线程个数--
decrementWorkerCount();
return null;
}
// 对数量的判断。
int wc = workerCountOf(c);
// 判断核心线程是否允许超时？
// 工作线程个数是否大于核心线程数
boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
// 判断工作线程是否超过了最大线程数 && 工作队列为null
if ((wc > maximumPoolSize || (timed && timedOut)) && (wc > 1 || workQueue.isEmpty())) {
// 工作线程数有问题，必须-1，干掉当前工作线程
// 工作线程是否超过了核心线程，如果超时，就干掉当前线程
// 对工作线程个数--
if (compareAndDecrementWorkerCount(c))
return null;
continue;
}
try {
// 如果是非核心，走poll，拉取工作队列任务，
// 如果是核心线程，走take一直阻塞，拉取工作队列任务
Runnable r = timed ?
workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
// 当工作队列没有任务时，这时就会被Condition通过await阻塞线程
// 当有任务添加到工作线程后，这是添加完任务后，就会用过Condition.signal唤醒阻塞的线程
workQueue.take();
if (r != null)
return r;
// 执行的poll方法，并且在指定时间没拿到任务，
timedOut = true;
} catch (InterruptedException retry) {
timedOut = false;
}
}
}
3.6 processWorkerExit方法-处理执行完的worker
processWorkerExit()方法是为将要终结的Worker做一次清理和数据记录工作
参数completedAbruptly记录了是否在run worker过程中发生异常
private void processWorkerExit(Worker w, boolean completedAbruptly) {
// 如果是不正常操作，需要先对工作线程数-- （如果正常情况，getTask就--了）
if (completedAbruptly)
decrementWorkerCount();
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
// 将当前工作线程完整的任务个数赋值给整个线程池中的任务数
completedTaskCount += w.completedTasks;
// 干掉当前工作线程
workers.remove(w);
} finally {
mainLock.unlock();
}
// 线程池是否可以中止，线程池状态是否发生变化。
tryTerminate();
int c = ctl.get();
//如果当前线程池状态小于STOP
if (runStateLessThan(c, STOP)) {
// 判断线程池中的工作队列是否还有任务，并且工作线程是否还在。
if (!completedAbruptly) {
int min = allowCoreThreadTimeOut ? 0 : corePoolSize;
if (min == 0 && ! workQueue.isEmpty())
min = 1;
if (workerCountOf(c) >= min)
return; // replacement not needed
}
// 添加非核心空任务的线程处理工作队列中的任务
addWorker(null, false);
}
}
