为什么要用线程池
- 重用存在的线程，减少对象创建销毁的开销
- 可有效的控制最大并发线程数，提高系统资源的使用率，同时避免多资源的竞争，避免堵塞
- 提供定时执行、定期执行、单线程、并发数控制等功能
方法使用
submit 是有返回值的，你要是不用返回值，直接用 execute 方法 另外一个是因为如果用 submit，如果线程池里面的任务执行的时候出异常了，会把异常封装到 Future 里面去，而你又不关心 Future，相当于把异常给吞了
public static void main(String[] args) {
ExecutorService executorService = Executors.newFixedThreadPool(100);
// 添加任务
executorService.execute(new Runnable() {
@Override
public void run() {
try {
Thread.sleep(20000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("结束");
}
});
System.out.println(executorService.isTerminated());
// shutdown 方法会终止接收任务，但是已经在队列里或者正在执行的任务不会被终止
// shutdownNow 会尝试使用 interrupt，interrupt 不能终止死循环 需要用 isInterrupted() 判断停止
executorService.shutdownNow();
// 等待线程池的任务执行完毕，可以设置一个可承受的时间，不用死循环也可以
while (!executorService.isTerminated()) {
try {
// 尝试终止 等待的时间，这个方法就是返回到时间后是否关闭线程池
executorService.awaitTermination(5, TimeUnit.SECONDS);
} catch (InterruptedException e) {
log.error(e.getMessage());
}
}
System.out.println(executorService.isTerminated());
}
构造方法
ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
RejectedExecutionHandler handler)
参数说明
- corePoolSize：核心线程数
- maximumPoolSize：最大线程数，包括核心线程数
- keepAliveTime ：线程存活时间，针对的是非核心线程数，没任务的时候，调用阻塞队列的 poll 方法，最多等待这么长时间，还没获取到就会被销毁
- unit ：存活时间单位
- workQueue ：任务队列
- threadFactory ：创建线程的工程
- handler ：拒绝策略
问题： 假设 定义了一个无界队列，核心线程一百个，最大线程数400个，这时候进了一万个并发，这时候有多少线程再跑？
非核心线程的创建时机：（1）核心线程数满了（2）queue 满了 同时满足两个条件 才会创建
大概流程是：
- 来一个任务，就 new 一个新核心线程，直到设置的核心线程最大数，也就是说：只要线程数没达到核心线程数，来一个任务就会创建一个核心线程。
- 再来任务，就放到任务队列里面，如果核心任务队列再满，比如说是10，等到队列到10，核心线程也都在运作，再创建非核心线程数，执行第21个任务，加入最大线程数是20。
- 如果最大线程数也满了，任务队列也满了，就会触发线程的拒绝策略，最后会由空闲下来的线程执行队列里的任务。
答： 所以是100个核心线程在跑
线程池的拒绝策略
等待队列已经排满了，再也塞不下新的任务，同时线程池中线程也达到了maximumPoolSize数量，无法继续为新任务服务，这个时候就需要拒绝策略来处理。
RejectedExecutionHandler rejected = null;
rejected = new ThreadPoolExecutor.AbortPolicy();//默认，队列满了丢任务抛出异常，直接抛出RejectedExecutionException异常阻止系统正常运行
所以如果提交任务时，线程池队列满了，丢任务之后会抛出RejectedExecutionException 异常，而不是简单的阻塞任务进入
rejected = new ThreadPoolExecutor.DiscardPolicy();//队列满了丢任务不抛出异常，直接丢弃任务，不予任何处理也不抛出异常，如果允许任务丢失，这是最好的一种方案
rejected = new ThreadPoolExecutor.DiscardOldestPolicy();//将最早进入队列的任务删除，之后在尝试加入队列，，抛弃队列中等待最久的任务，然后把当前任务加入队列中尝试再次提交当前任务
rejected = new ThreadPoolExecutor.CallerRunsPolicy();//如果添加到线程池失败，那么主线程会自己去执行该任务，调用者运行一种调节机制，该策略不会丢弃任务，也不会抛出异常，而是将某些任务回退给调用者，从而降低新任务的流量
JDK 自带的线程池
ExecutorService threadPool = null;
threadPool = Executors.newCachedThreadPool();//有缓冲的线程池，大小无界，最大线程数是int的最大数，存活时间60秒，池中的线程数随任务的多小变化，高并发情况下，几万个请求，或者更多，会出现内存激增，很大可能会出现宕机情况。
threadPool = Executors.newFixedThreadPool(3);//固定大小的线程池，任务队列无界的线程池。在高并发情况下轻则会影响响应速度，重则丢数据，还有可能造成死机，宕机，虽然可能性不大，但是因为线程池的拒绝策略会抛出很多异常。
threadPool = Executors.newScheduledThreadPool(3) 定时执
行任务的线程池，内部使用的队列是 DelayQueue，无界队列，和 newFixedThreadPool 一样的问题，最大线程数是 Integer.MAX_VALUE ，会根据任务一直创建线程
threadPool = Executors.newSingleThreadExecutor();//单线程的线程池，任务队列无界
上述都是由Executors工具类创建
threadPool = new ThreadPoolExecutor();//默认线程池，可控参数比较多
源码解析
重要参数
// int 类型有 32 位，高 3 位表示线程池的状态，低 29 位表示 worker 数量
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
private static final int COUNT_BITS = Integer.SIZE - 3;
private static final int CAPACITY = (1 << COUNT_BITS) - 1;
// runState is stored in the high-order bits
// RUNNING: 十进制:-536870912 二进制:11100000000000000000000000000000
private static final int RUNNING = -1 << COUNT_BITS;
// SHUTDOWN: 十进制:0 二进制:0
private static final int SHUTDOWN = 0 << COUNT_BITS;
// STOP: 十进制:536870912 二进制:00100000000000000000000000000000
private static final int STOP = 1 << COUNT_BITS;
// TIDYING: 十进制:1073741824 二进制:01000000000000000000000000000000
private static final int TIDYING = 2 << COUNT_BITS;
// TERMINATED: 十进制:1610612736 二进制:01100000000000000000000000000000
private static final int TERMINATED = 3 << COUNT_BITS;
execute 方法
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
/*
* Proceed in 3 steps:
*
* 1. 如果正在运行的线程少于 corePoolSize，请尝试使用给定命令作为其第一个任务启动一个新线程。
* 对 addWorker 的调用以原子方式检查 runState 和 workerCount，
* 从而通过返回 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. 如果我们无法排队任务，那么我们尝试添加一个新线程（核心线程外的工作线程）。
* 如果它失败了，我们知道我们已经关闭或饱和，因此拒绝该任务。
*/
int c = ctl.get();
if (workerCountOf(c) < corePoolSize) {
// 第二个参数：是不是核心线程
if (addWorker(command, true))
return;
c = ctl.get();
}
// 2. 线程池状态是 Running，任务进入队列；不是 Running 说明执行过 shutdown 方法
if (isRunning(c) && workQueue.offer(command)) {
// 复查，因为可能加入队列后，线程池状态变了
int recheck = ctl.get();
// 状态改变，出队
if (!isRunning(recheck) && remove(command)) {
// 根据拒绝策略做对应操作
reject(command);
// 允许核心线程数为 0 ，所以在这判断一下是否等于 0，如果为 0 新建线程，不为 0 这个方法就结束了，任务已经入队
// 上面任务已经入队了，所以这里 firstTask 为 null
} else if (workerCountOf(recheck) == 0)
addWorker(null, false);
}
// 3. 队列满了才会尝试添加到队列中，失败就根据拒绝策略做对应操作
else if (!addWorker(command, false))
reject(command);
}
addWorker 方法
private boolean addWorker(Runnable firstTask, boolean core) {
// CAS + 死循环方式让 worker（工作线程） 的数量 + 1
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;
// cas 方式增加一个线程数量
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 {
// new Worker，启动一个线程
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();
// 把新的工作线程 worker 放到集合里
workers.add(w);
int s = workers.size();
// 记录一下线程池在运行中线程数量的最大值
if (s > largestPoolSize)
largestPoolSize = s;
workerAdded = true;
}
} finally {
mainLock.unlock();
}
// 启动 worker 线程
if (workerAdded) {
t.start();
workerStarted = true;
}
}
} finally {
// 如果添加worker失败了，需要进行 shutdown 操作
if (!workerStarted)
addWorkerFailed(w);
}
return workerStarted;
}
Worker 代码解析
构造方法
private final class Worker
extends AbstractQueuedSynchronizer
implements Runnable
Worker(Runnable firstTask) {
setState(-1); // inhibit interrupts until runWorker
this.firstTask = firstTask;
// 创建新的线程
this.thread = getThreadFactory().newThread(this);
}
为什么继承 AQS
其实就是为了区分工作线程和空闲线程，在调用 shutdown 方法的时候判断是否停止线程。
Worker 的 run 方法
public void run() {
runWorker(this);
}
final void runWorker(Worker w) {
Thread wt = Thread.currentThread();
// 取第一个任务
Runnable task = w.firstTask;
w.firstTask = null;
// 将 state 设置为 0，表示这时候是可中断的，因为 Worker 初始化的 state = -1
// 而调用 shutdown 的时候，只有 Worker 的 state 是 0 的时候才会调用 interrupt()
w.unlock(); // allow interrupts
// 是否是异常退出，在拿不到任务退出的时候 completedAbruptly = false 是正常退出
boolean completedAbruptly = true;
try {
// 获取任务
while (task != null || (task = getTask()) != null) {
// 加锁，不是为了防止并发执行任务，为了在 shutdown()时不终止正在运行的 worker
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
// 如果线程池正在被停止，确保线程被中断；如果线程池没有被停止，那么就不中断线程
// 中断线程之后，会把这次的任务执行完
// 如果是 STOP 或 TIDYING、TERMINATED 状态
if ((runStateAtLeast(ctl.get(), STOP)
// 清除中断状态，如果没有被中断，返回 false
|| (Thread.interrupted()
// 如果是 STOP 或 TIDYING、TERMINATED 状态
&& runStateAtLeast(ctl.get(), STOP)))
// 没有被中断
&& !wt.isInterrupted())
// 那么调用中断方法
wt.interrupt();
try {
// 这里默认是没有实现的，在一些特定的场景中我们可以自己继承 ThreadPoolExecutor 自己重写
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 {
// 帮助 GC？
task = null;
// 执行成功的任务数量++
w.completedTasks++;
// 解锁
w.unlock();
}
}
completedAbruptly = false;
} finally {
// 处理 Worker 退出，一种是异常退出，一种是工作线程（一般是普通线程<非核心>）空闲时间到了退出
// completedAbruptly 为 true 说明是异常退出
processWorkerExit(w, completedAbruptly);
}
}
getTask 取任务方法
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.
// 判断线程池状态，是 大等于 SHUTDOWN 并且（ STOP <调用了 shutdownNow> 或者 任务队列是空），取不到数据 直接返回
if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
// 线程数量 - 1，返回 null ，外边的方法会把当前 worker 从集合里移出
decrementWorkerCount();
return null;
}
// 下面就是获取到任务了
int wc = workerCountOf(c);
// Are workers subject to culling?
// allowCoreThreadTimeOut 默认是 false : 如果为 false（默认），核心线程即使在空闲时也保持活动状态。
// 如果为 true，则核心线程使用 keepAliveTime 超时等待工作。
// 或者当前线程数大于核心线程数
boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
// 如果当前线程数大于最大线程，可能是线程池在运行时被调用了 setMaximumPoolSize() 被改变了大小，否则这个条件不会满足
// timedOut 表示上次处理任务是否超时 会在处理任务后 ，设置 timedOut = true
if ((wc > maximumPoolSize || (timed && timedOut))
&& (wc > 1 || workQueue.isEmpty())) {
// CAS 减少，保证线程安全
if (compareAndDecrementWorkerCount(c))
return null;
continue;
}
try {
// 当前线程数大于核心线程数，用 poll 方法，如果没数据会返回 null
Runnable r = timed ?
// 最多阻塞这么长时间，还没取到那就说明超过存活时间
workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
// timed 为 false 一直等着来新任务
workQueue.take();
// 取到了直接返回任务
if (r != null)
return r;
// 没取到 把 timeOut 设置为 true，下次循环就把这个县城给删除了
timedOut = true;
} catch (InterruptedException retry) {
timedOut = false;
}
}
}
processWorkerExit Worker 退出方法
private void processWorkerExit(Worker w, boolean completedAbruptly) {
// 突然退出， worker 的 count - 1
// 因为正常退出，workerCount减1这件事情是在getTask拿不到任务的情况下做掉的。
if (completedAbruptly) // If abrupt, then workerCount wasn't adjusted
decrementWorkerCount();
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
// w.completedTasks 是这个线程完成的任务数
completedTaskCount += w.completedTasks;
// 删掉这个工作线程
workers.remove(w);
} finally {
mainLock.unlock();
}
// 每次 worker 结束的时候都要尝试关闭线程池，因为可能线程池调用 shutdown 了
tryTerminate();
int c = ctl.get();
// 线程池状态没有小于 STOP 说明没有停止
if (runStateLessThan(c, STOP)) {
// 不是异常退出，保证 RUNNING 或 SHUTDOWN 状态下最少需要的工作线程数。
if (!completedAbruptly) {
int min = allowCoreThreadTimeOut ? 0 : corePoolSize;
if (min == 0 && ! workQueue.isEmpty())
min = 1;
if (workerCountOf(c) >= min)
return; // replacement not needed
}
// 是异常退出，新添加一个 Worker，任务去队列取
addWorker(null, false);
}
}
