前言
java 线程池主要有三方面- 线程池的创建，涉及的参数，线程队列、拒绝策略
- 线程池的线程状态与切换
- 线程池的执行线程任务的流程与原理
线程池的创建
java中提供了几个线程池的实现：newFixedThreadPool、newCachedThreadPool、newScheduledThreadPool、newSingleThreadExecutor，底层的实现都是用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.corePoolSize = corePoolSize;
this.maximumPoolSize = maximumPoolSize;
this.workQueue = workQueue;
this.keepAliveTime = unit.toNanos(keepAliveTime);
this.threadFactory = threadFactory;
this.handler = handler;
}
- corePoolSize：线程池中核心线程的数量
- maximumPoolSize：线程池中允许的最大的线程数
- keepAliveTime：非核心线程的存活时间。当系统中有非核心线程存在，并且没有待处理的线程处理，允许存活的时间，线程池中还有一个变量 allowCoreThreadTimeOut，这个用来设置核心线程是否也有keepalive时间限制，如果开启了，那么核心线程也不是常驻线程池中，也会在空闲的时候被关闭。
- unit：keepAliveTime的时间单位
- workQueue：阻塞队列，当没有工作线程可以新任务时，就会被添加到这个队列
- threadFactory：线程池的线程工厂，用来创建线程的
- handler：线程池的拒绝处理器，当线程池不能处理新任务时，则用拒绝处理器来处理。
线程池的状态
线程池有5个状态：RUNNGING、SHUTDOWN、STOP、TIDYING、TERMINATED
- RUNNGING:线程池被创建的时候，就处于RUNNING 状态
- SHUTDOWN：当线程池执行shutdown()方法时，进入SHUTDOWN状态，进入SHUTDOWN状态的线程，不会接受新的任务，但是会把队列中的任务处理掉
- STOP：当线程池执行shutdownNow()方法时，进入STOP状态，进入STOP状态的线程，不会接受新的任务，不会处理队列中的任务，以及中断正在处理的任务
- TIDYING：当所有的任务都已经处理完成时，则进入这个状态，准备要执行terminate()方法来结束线程池，在JAVA默认实现中，terminate方法是空的。
- TERMINATED：当terminate方法被执行完成后，线程池就被关闭了，在java默认实现中，TIDYING跟TERMINATED是一起的，因为terminate方法为空
线程池状态图
线程池源码分析
线程池中主要是提交任务处理、停止线程，中止线程等操作。所有的实现都在ThreadPoolExecutor对象中完成
ThreadPoolExecutor中的状态
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
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;
// Packing and unpacking ctl
private static int runStateOf(int c) { return c & ~CAPACITY; }
private static int workerCountOf(int c) { return c & CAPACITY; }
private static int ctlOf(int rs, int wc) { return rs | wc; }
在线程池中的核心变量就是ctl，这个变量有两个作用，既表示线程的状态，又表示线程中工作线程的数量。这个变量的高三位是线程的状态值，变量的低29位是工作线程数，所以线程池中最大的线程数是2^29-1（CAPACITY），所以可见方法workerCountOf表示当前线程池中工作线程数就是用c与CAPACITY的与（取低29位）；而runStateOf是获取线程池的状态，就是用c与CAPACITY的非的与（取低29位的反，表明取高三位）
线程池任务提交 submit
我们提交任务调用submit方法
public Future<?> submit(Runnable task) {
if (task == null) throw new NullPointerException();
RunnableFuture<Void> ftask = newTaskFor(task, null);
execute(ftask);
return ftask;
}
newTaskFor方法是把runnable方法封装成futuretask（后面分析这个方法），然后执行。
提交任务的主要步骤是：execute –> addWorker –>runworker （getTask）
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();
//1.如果工作线程数小于核心线程数阈值，则直接把任务添加到工作线程中执行
if (workerCountOf(c) < corePoolSize) {
if (addWorker(command, true))
return;
c = ctl.get();
}
//2.添加到工作线程失败，判断当前线程池的状态是RUNNGING，并且把任务添加到
//阻塞队列中
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);
}
//3.如果添加到阻塞队列也失败了，则再次尝试添加到工作线程中看下是否成功，如果还是失败
//则执行拒绝策略
else if (!addWorker(command, false))
reject(command);
}
以上是创建线程执行的流程：
- 检查当前线程池的运行线程数，如果小于核心线程数，则说明当前线程池中运行线程数少，可以直接将task添加到核心线程中；
- 如果当前线程数大于核心线程数，则将任务添加到等待队列中；添加成功后，会再次检查线程池的状态，如果在添加队列过程中，线程池的状态发生改变，不再是运行态，那么则说明添加任务时，线程池处于关闭中状态，那么就需要把刚才添加的任务剔除，执行reject策略
- 如果添加队列失败，则添加到非核心线程任务中处理；如果非核心线程不能创建成功，则执行reject策略
从源码上看任务添加过程跟理解的原理是一致的。下面看下addWorker的源码实现
Worker(Runnable firstTask) {
setState(-1); // inhibit interrupts until runWorker
this.firstTask = firstTask;
this.thread = getThreadFactory().newThread(this);
}
private boolean addWorker(Runnable firstTask, boolean core) {
retry:
//1.这个是CAS无锁方式来尝试增加work线程数，如果线程池状态不是RUNNING，则直接返回失败
for (;;) {
int c = ctl.get();
int rs = runStateOf(c);
// Check if queue empty only if necessary.
// 如果当前线程池状态是SHUTDOWN以上，或者线程池状态是SHUTDOWN并且任务为null并且队列不为空，则返回添加失败
if (rs >= SHUTDOWN &&
! (rs == SHUTDOWN &&
firstTask == null &&
! workQueue.isEmpty()))
return false;
//1.1 根据当前线程池中的线程数量判断是否有条件创建新的线程，如果超过线程池数量限制，则返回失败
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
}
}
//2. 把任务添加到worker线程队列中
boolean workerStarted = false;
boolean workerAdded = false;
Worker w = null;
try {
// 创建work对象，包装任务
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();
//2.1把这个worker添加到
workers.add(w);
int s = workers.size();
if (s > largestPoolSize)
largestPoolSize = s;
workerAdded = true;
}
} finally {
mainLock.unlock();
}
//3 启动这个线程
if (workerAdded) {
t.start();
workerStarted = true;
}
}
} finally {
if (! workerStarted)
addWorkerFailed(w);
}
return workerStarted;
}
addWorker 的主要工作就是把任务提交到work线程中执行，线程池中所有的工作都在worker对象中完成。workerr类封装了任务，并且封装了一个线程thread，就是这个thread来执行这个任务。线程池就是通过这个worker集合来维护线程池的线程，只要worker不被移除，那么这个线程就可以重复读取任务来执行，避免线程被反复创建，降低资源消耗，getTask方法中有对应的实现
addworker中主要完成以下步骤：
4. 增加线程池中线程数，CAS操作修改线程池状态变量ctl，这里有两个for循环，其实一个循环也能实现，内循环主要是CAS操作，外循环涉及到线程池状态的判断，如果这时候读取到线程状态不是RUNNGIN的，或者当前线程池中线程数满了，那么就会返回添加失败
2.添加线程计数成功后，增加一个worker对象（新建一个线程，并且把当前任务作为这个线程的第一个执行任务，添加到worker线程集合中）就把新创建的worker对象添加到集合中去。这个添加过程中也是需要对线程池状态、线程状态进行检测，如果非运行态的线程池，则
5. 当添加成功后，就开始执行这个线程，调用thread的start方法，启动线程的地方是worker中thread的start，在前面的worker定义中，thread中传入的任务就是自己，因为worker对象实现了runnable接口，那么thread启动的时候执行的就是worker对象的run方法，而run方法中执行的就是线程池的核心方法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 {
//1. 循环处理task，这个是线程池服用线程的原理，核心是getTask
while (task != null || (task = getTask()) != null) {
//1.1这里加锁是为了确保这个woker在执行的时候是被保护的，但是我在代码中
//发现只有这一个地方使用加锁，里面主要是从队列中取出task执行，队列是阻塞队列
//不会有问题，然后就是前置、后置方法，默认实现都是空，最后就是completedTasks自增
//因为runWorker本身就是在内部的thread对象线程上执行的，没有其他的地方会调用？
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 {
//2.1 在执行任务前的前置操作，可以重载实现
beforeExecute(wt, task);
Throwable thrown = null;
try {
//2.2执行任务
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 {
//2.3 完成任务后的后置操作，默认是空，可以重载实现
afterExecute(task, thrown);
}
} finally {
task = null;
//设置这个线程完成的任务数
w.completedTasks++;
//解锁
w.unlock();
}
}
completedAbruptly = false;
} finally {
//当没有任务处理的时候，要处理worker线程，这里的worker线程是非常驻核心线程
processWorkerExit(w, completedAbruptly);
}
}
runWorker方法主要就是执行被传入的任务，以及阻塞队列的任务。当没有任务的时候，就会根据keepaliveTime来确认这个线程是否要被关闭。详细流程在代码注释中
这里看下getTask方法，这个方法就是从阻塞队列中获取任务，如果获取到任务就返回，如果没有获取到任务，则判断当前的工作线程是否是核心线程，如果是的话则阻塞当前线程获取任务，如果不是，则说明当前线程不是核心线程，那么在等待keepalive时间后释放当前线程 。
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.
//1.如果当前线程池的状态是stop以上或者是shutdown并且队列为空，那么就设置线程池状态工作线程数减1
//在runWorker方法中从worker队列中移除这个线程
if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
decrementWorkerCount();
return null;
}
int wc = workerCountOf(c);
// Are workers subject to culling?
//2.这里是keepalive的起作用的地方，allowCoreThreadTimeOut是线程池中用来
//设置核心线程是否允许常驻的，默认这个配置是关闭的，java提供的几种线程池都是关闭的
boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
//2.1只有核心线程之外的线程才对keepalive有作用，对于核心线程外的线程，如果任务队列为空
//那么这个线程就要被关闭
if ((wc > maximumPoolSize || (timed && timedOut))
&& (wc > 1 || workQueue.isEmpty())) {
if (compareAndDecrementWorkerCount(c))
return null;
continue;
}
//3.如果当前线程是核心线程，那么就会阻塞在获取队列任务上，队列中有任务则会返回任务
//如果没有任务，则阻塞，一直等到有任务来，这就是核心线程常驻的实现
//如果当前线程不是核心线程，那么会在keepalive的超时时间内获取任务，如果队列有任务，则返回
//任务，如果没有任务，那就说明当前线程空闲时间超过了keepalive时间，要被关掉，这里是设置timeout
//再次循环的时候会执行到2.1部分
try {
Runnable r = timed ?
workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
workQueue.take();
if (r != null)
return r;
timedOut = true;
} catch (InterruptedException retry) {
timedOut = false;
}
}
}
所以这个方法返回的就是队列中的任务，是根据当前的线程数决定的，如果当前的线程数超过核心线程数，那么当前的线程是被当做非核心线程，是会等待keepalive时间从队列获取，最终返回任务或者null；如果当前线程数小于核心线程数，那么当前线程就被当做核心线程，阻塞等待任务；着就是我们使用线程池的时候，核心线程一直存在，非核心线程超时关闭的实现机制。
回到方法runWorker方法里面。当getTask返回的是null的时候，就会跳出while循环，执行finally部分，就是用来释放当前线程的，因为如果当前线程是核心线程的话，getTask方法是阻塞不返回的，这里返回，则说明当前线程是非核心线程。
最后看下processWorkerExit方法，这个方法就处理多余的工作线程，让线程退出，注意一点的是，在最后会创建一个空任务的worker对象，目的是当线程池中线程数量小于工作线程数是，创建一个worker对象增加工作线程，以便当有任务的时候不用再创建线程。
private void processWorkerExit(Worker w, boolean completedAbruptly) {
if (completedAbruptly) // If abrupt, then workerCount wasn't adjusted
decrementWorkerCount();
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
completedTaskCount += w.completedTasks;
workers.remove(w);
} finally {
mainLock.unlock();
}
tryTerminate();
int c = ctl.get();
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);
}
}
这个方法中只有将worker从set中删除，但是没有减少线程数，减少的动作在getTask里面做的；当当前的工作线程数小于核心线程数的时候，则会执行addWorker(null, false)方法，之所以要这个方法，是因为我们在线程并发的时候，会出现两个线程同时检测自己为非核心线程而关闭线程，这里是做一个弥补，如果当前线程数小于核心线程数，则创建一个空任务的线程，这个空任务的线程就会继续循环读取队列取出任务，这样可以确保有coreSize的核心线程在运行
流程图
1322
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
