目录
[Worker 中run方法代码](#Worker 中run方法代码)
[getTask()方法 获取任务](#getTask()方法 获取任务)
线程池的基本原理
Java线程池主要用于管理线程组及其运行状态，以便Java虚拟机更好的利用CPU资源。Java线程池的工作原理为：JVM先根据用户给定的参数创建一定数量的可运行的线程任务，并将其放入队列中，在线程创建后启动这些任务，如果正在运行的线程数量超过了最大线程数量(用户设置的线程池大小)，则超出数量的线程排队等候，在有任务执行完毕后，线程池调度器会发现有可用的线程，进而再次从队列中取出任务并执行。
线程复用
在Java中，每个Thread类都有一个start方法。在程序调用start方法启动线程时，Java虚拟机会调用该类的run方法。在Thread类的run方法中其实调用了Runnable对象的run方法，吟慈可以继承Thread类，在start方法中不断循环调用传递进来的Runnable对象，程序就会不断执行run方法中的代码。可以将再循环方法中不断获取的Runnable对象放在Queue中，当线程在获取下一个Runnable对象之前是阻塞的，这样既能有效控制正在执行的线程个数，也能保证系统中正在等待执行的其他线程有序执行。
ava中的线程池是通过Executor框架实现的，在该框架中用到了Executor、Executors、ExecutorService、ThreadPoolExecutor、Callable、Future、FutureTask这几个核心类。其中tahreadPoolExecutor是构建线程的核心方法，方法定义如下
ThreadPoolExecutor构造函数的具体参数如下：
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler) {
...
}
-
corePoolSize：线程池中核心线程的数量
-
maximumPoolSize：线程池中最大线程的数量
-
keepAliveTime：当前线程数量超过corePoolSize时，空闲线程的存活时间
-
unit：keepAliveTime的时间单位
-
workQueue：任务队列，被提交但尚未被执行的任务存放的地方
-
threadFactory：线程工厂，用于创建线程，可使用默认的线程工厂或自定义线程工厂
-
handler：由于任务过多或者其他原因导致线程池无法处理时的任务拒绝策略
线程池的核心组件和核心类
Java线程池主要由以下4个核心组件组成
-
线程池管理器：用户创建并管理线程池
-
工作线程：线程池中执行具体任务的线程
-
任务接口：用于定义工作线程的调度和执行策略，只有线程实现了该接口，线程中的任务才能够被线程池调度。
-
任务队列：存放待处理的任务，新的任务将会不断被加入队列中，执行完成的任务将被从队列中移除。
为什么要线程池？
线程的作用？
能够异步处理任务，并且能处理多个任务，但是无限制的使用线程，线程 之间的创建、销毁，切换，都会带来一定的消耗！所以，为了控制线程的 数量，复用已有线程，同时减少线程切换带来的开销，所以，线程池这种 池化技术就出来了！！
- 降低资源消耗：重复利用已创建的线程，降低线程创建和销毁造成的损 耗。
- 提高响应速度：任务到达时，无需等待线程创建即可立即执行。
- 提高线程的可管理性：使用线程池可以进行统一的分配、调优和监控。
- 提供更多更强大的功能：线程池具备可拓展性，允许开发人员向其中增加更多的功能。
核心思想
固定的线程数，来消费不定量的 task
线程池封装了很多很多的现成的用法
newFixedThreadPool ：该方法返回一个固定数量的线程池，线程数不变，当有一个任务提交时，若线
程池中空闲，则立即执行，若没有，则会被暂缓在一个任务队列中，等待有空闲的线程去执行。
**newSingleThreadExecutor:**创建一个线程的线程池，若空闲则执行，若没有空闲线程则暂缓在任务队 列中。
newCachedThreadPool：返回一个可根据实际情况调整线程个数的线程池，不限制最大线程数量，若 用空闲的线程则执行任务，若无任务则不创建线程。并且每一个空闲线程会在 60 秒后自动回收
**newScheduledThreadPool:**创建一个可以指定线程的数量的线程池，但是这个线程池还带有延迟和周 期性执行任务的功能，类似定时器。
newWorkStealingPool: 适合使用在很耗时的操作，但是 newWorkStealingPool 不是 ThreadPoolExecutor的扩展，它是新的线 程池类 ForkJoinPool 的扩展，但是都是在统一的一个 Executors 类中实现，由于能够合理的使用 CPU进行 对任务操作（并行操作），所以适合使用在很耗时的任务中
ExecutorService executorService= Executors.newFixedThreadPool(2);
for (int i = 0; i < 10; i++) {
executorService.execute(new Thread(() -> {
System.out.println(Thread.currentThread().getName() + "执 行任务");
}));
}
executorService.shutdown();
}
ExecutorService executor= Executors.newFixedThreadPool(5);
for (int i = 0; i < 50; i++) {
executor.execute(
new Thread(()->{
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("测 试"+Thread.currentThread().getName());
}));
}
executorService.shutdown();
除了newWorkStealingPool，都是对ThreadPoolExecutor的一层封 装！！并且，建议大家不要用这些封装的，用底层的 ThreadPoolExecutor，这样你就逼着自己去把线程池的一些参数去搞明 白！！并且能提供比封装的更多功能！比如监控！！今天我们就去看下 ThreadPoolExecutor中怎么去实现固定的线程数，来消费我们不定量的 task！！
线程池的工作流程
Java线程池的工作流程为：线程池刚被创建时，只是向系统申请一个用于执行线程队列和管理线程池的线程资源。在调用execute()添加一个任务时，线程池会按照以下流程执行任务。
-
如果正在运行的线程数量少于corePoolSize（用户定义的核心线程数），线程池就会立刻创建线程并执行该线程任务
-
如果正在运行的线程数量大于等于corePoolSize，该任务就将被放入阻塞队列中
-
在阻塞队列已满且正在运行的线程数量少于maximumPoolSize时，线程池会创建非核心线程立刻执行该线程任务
-
在阻塞队列已满且正在运行的线程数量大于等于maximumPoolSize时，线程池将拒绝执行该线程任务并抛出RejectException异常
-
在线程任务执行完毕后，该任务将被从线程池队列中移除，线程池将从队列中取下一个线程任务继续执行
-
在非核心线程处于空闲状态的时间超过keepAliveTime时间时，正在运行的线程数量超过corePoolSize，该非核心线程将会被认定为空闲线程并停止。因此，在线程池中所有线程任务都执行完毕后，线程池会收缩到corePoolSize大小。
流程图
源码解析
初始化
public ThreadPoolExecutor(int corePoolSize,//核心线程程数
int maximumPoolSize,//最大线程数
long keepAliveTime,//线程存活时间
TimeUnit unit,//线程存活时间单位
BlockingQueue<Runnable> workQueue,//阻塞队列，我们需要执行的task都在该队列
ThreadFactory threadFactory//生成thread的工厂,
RejectedExecutionHandler handler//拒绝饱和策略，当队列满了并且线程个数达到 maximunPoolSize 后采取的策略 ) {
this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
threadFactory, handler);
}
启动调用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();//0
//workerCountOf 高三位代表线程池的状态，低29位代表线程池中的线程数量
//如果线程数小于主线程数，添加线程
if (workerCountOf(c) < corePoolSize) {
if (addWorker(command, true))
return;
c = ctl.get();
}
//如果超过主线程数，将任务添加至workqueue 阻塞队列
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()方法
private boolean addWorker(Runnable firstTask, boolean core) {
retry://goto语句
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))//cas添加线程
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);//开启一个线程，Worker实现了runnable接口
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);//添加至wokers
int s = workers.size();
if (s > largestPoolSize)
largestPoolSize = s;
workerAdded = true;
}
} finally {
mainLock.unlock();
}
if (workerAdded) {//添加成功
t.start();//启动线程，会调用我们线程的run接口，也就是我们worker的run
workerStarted = true;
}
}
} finally {
if (! workerStarted)
addWorkerFailed(w);
}
return workerStarted;
}
goto语句demo
retry:
for (int i = 0; i < 3; i++) {
for (int j = 3; j < 10; j++) {
if (j == 7) {
continue retry; //继续外面循环
}
System.out.println(i+":"+j);
}
}
Worker()方法
Worker(Runnable firstTask) {
setState(-1); // inhibit interrupts until runWorker禁止中断，直到runWorker
this.firstTask = firstTask;
//根据传入的线程工厂去创建一个线程，runnable为worker
this.thread = getThreadFactory().newThread(this);
}
Worker 中run方法代码
public void run() {
runWorker(this);
}
runWorker()方法
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，就一直会执行，不会关闭，所以线程也不 会销毁，线程销毁只有当task为null
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();//调用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);
}
}
getTask()方法 获取任务
private Runnable getTask() {
boolean timedOut = false; // Did the last poll() time out?
//自旋获取
for (;;) {
int c = ctl.get();
int rs = runStateOf(c);
必要时检 查空，状态是否停止或者shutdown
// 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?
//线程数大于主线程数时，或者allowCoreThreadTimeOut参数为true allowCoreThreadTimeOut默认为false
boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
//超过最大线程，或者timed为true ,&& wc大于1个，并且任务队列为空的时候
if ((wc > maximumPoolSize || (timed && timedOut))
&& (wc > 1 || workQueue.isEmpty())) {
//线程数-1，并且返回null，该线程结束
if (compareAndDecrementWorkerCount(c))
return null;
continue;
}
try {//如果time是true，超过时间不阻塞，不然一直阻塞，不回收
Runnable r = timed ?
workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) ://移除并返回队列头部的元素，如果为空，超 过时间返回null
workQueue.take();//移除并返回队列头部的元素，如果为空,一直阻塞
if (r != null)
return r;
timedOut = true;
} catch (InterruptedException retry) {
timedOut = false;
}
}
}
最大线程数什么场景才会用到
task线程添加不进去，满了
举例设置阻塞队列的大小
ExecutorService executorService = new ThreadPoolExecutor(2, 3,10, TimeUnit.MILLISECONDS
, new LinkedBlockingQueue<>(3),new ExecJavaTemplate());
//executorService.allowCoreThreadTimeOut(true);
for (int i = 0; i < 10; i++) {
executorService.execute(new Thread(() -> {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "执行任务");
}));
}
拒绝策略
public class ExecJavaTemplate implements RejectedExecutionHandler {
@Override
public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
System.out.println("把任务继续执行完"+r.toString());
executor.execute(r);
}
}
若线程池中的核心线程数被用完且阻塞队列已满，则此时线程池的线程资源已耗尽，线程池将没有足够的线程资源执行新的任务。为了保证操作系统的安全，线程池将通过拒绝策略处理新添加的线程任务。jdk内置的拒绝策略有AbortPolicy、CallerRunsPolicy、DiscardOldestPolicy、DiscardPolicy这4种，默认的拒绝策略在ThreadPoolExecutor中作为内部类提供。
1、AbortPolicy 直接抛出异常，组织线程正常运行
2、CallerRunsPolicy 如果被丢弃的线程任务未关闭，则执行该线程任务
3、DiscardOldestPolicy 移除线程队列中最早的一个线程任务，并尝试提交当前任务
4、DiscardPolicy 丢弃当前的线程任务而不做任何处理。
线程的回收
getTask()返回null,线程结束
线程池关闭
public void shutdown() {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
// 权限校验，安全策略相关判断
checkShutdownAccess();
// 设置SHUTDOWN状态
advanceRunState(SHUTDOWN);
// 中断所有的空闲的工作线程
interruptIdleWorkers();
onShutdown(); // hook for
ScheduledThreadPoolExecutor
} finally {
mainLock.unlock();
}
tryTerminate();
}
注意，shutdown不会终止正在运行的线程，只能通过线程的状态去自旋中断，然后结束线程
线程设置多少合适
线程数 = CPU可用核心数/(1 - 阻塞系数），其中阻塞系数的取值在0和1之
间。阻塞系数=阻塞时间/(阻塞时间+计算时间)。
线程的 CPU 耗时所占比例越高，就需要越少的线程
线程的 IO 耗时所占比例越高，就需要越多的线程
针对不同的程序，进行对应的实际测试就可以得到最合适的选择
线程数 >= CPU 核心数