一、简介
1、它就是线程池内部处理逻辑的核心类，它定义了线程池内部的处理规则，包括：任务的接收，任务的饱和拒绝策略，工作线程集合和任务阻塞队列的管理，任务的执行和线程池的状态等的管理。
2、它的内部类Worker继承了AQS，所以，工作线程在执行时可以进行锁的管理，异常的中断和返回等。
3、整个并发框架中，将工作单元和执行机制分离开，工作单元包括：Runnable和Callable，而执行机制由Excutor框架提供。
延展：Executor是执行机制的顶层接口，只定义了一个方法：void execute(Runnable command)
ExecutorService接口继承了Excutor，是执行机制的第二层接口，里面有更丰富的方法，包括shutdown，submit等方法。
Executors可以理解为是并发框架中的一个工具类。它主要的四大功能是：
1、创建并返回一个ExecutorService实例
2、创建并返回一个ScheduledExecutorService
3、创建并返回一个ThreadFactory
4、创建并返回一个Callable
4、线程池中有工作集合和阻塞队列，阻塞队列一般有SynchronousQueue、LinkedBlockingQueue和ArrayBlockingQueue；
SynchronousQueue：CachedThreadPool线程池使用到了这个阻塞队列，也是一种无界的，线程池数可达到Integer.MAX_VALUE ， 和newFixedThreadPool创建的线程池不同，newCachedThreadPool在没有任务执行时，当线程的空闲时间超过keepAliveTime，会自动释放线程资源，当提交新任务时，如果没有空闲线程，则创建新线程执行任务，会导致一定的系统开销
LinkedBlockingQueue：也是无界阻塞队列，内部使用的链表来充当阻塞队列，队列容量为Integer.MAX_VALUE ，并且maximumPoolSize也失效
ArrayBlockingQueue：是有界的队列，内部使用的Object数组来充当，所以队列的大小在初始化时就定好了。
5、饱和策略：当线程池满了，这时有其他的任务被提交进来，会执行饱和策略，饱和策略默认是抛出异常，你也可以重写RejectedExecutionHandler类来自定义拒绝策略。
6、ThreadPoolExecutor内部也使用了ReentrantLock来加锁，Condition作为条件队列
7、如果ThreadPoolExecutor内部的阻塞队列使用的无界的，那么，maximumPoolSize和keepAliveTime将无效。
8、它内部的一个重要属性：ctl，是AtomicInteger类型的，原子类型，保证线程安全，它又可以拆为两部分：高三位（代表了线程池的状态）和低29位（代表了线程池中的运行线程数），对ctl的操作使用了CAS！（compareAndDecrementWorkerCount、compareAndIncrementWorkerCount和compareAndSet）
9、关闭线程池的原理：遍历线程池中的所有线程，然后逐个调用线程的interrupt方法来中断线程
10、两种关闭线程池的实现方式：shutdown和shutdownNow
shutdown：将线程池里的线程状态设置成SHUTDOWN状态, 然后中断所有没有正在执行任务的线程
shutdownNow：比shutdown更绝，将线程池里的线程状态设置成STOP状态, 然后停止所有正在执行或暂停任务的线程. 只要调用这两个关闭方法中的任意一个
二、原理
其实java线程池的实现原理很简单，说白了就是一个线程集合workerSet和一个阻塞队列workQueue。当用户向线程池提交一个任务(也就是线程)时，线程池会先将任务放入workQueue中。workerSet中的线程会不断的从workQueue中获取线程然后执行。当workQueue中没有任务的时候，worker就会阻塞，直到队列中有任务了就取出来继续执行。
当一个任务提交至线程池之后:
- 线程池首先当前运行的线程数量是否少于corePoolSize。如果是，则创建一个新的工作线程来执行任务。如果都在执行任务，则进入2.
- 判断BlockingQueue是否已经满了，倘若还没有满，则将线程放入BlockingQueue。否则进入3.
- 如果创建一个新的工作线程将使当前运行的线程数量超过maximumPoolSize，则交给RejectedExecutionHandler来处理任务。
当ThreadPoolExecutor创建新线程时，通过CAS来更新线程池的状态ctl.
三、源码
重要参数
//ctl是一个重要的变量，用来存放当前运行的worker数量以及线程池状态的。int是32位的，这里把int的高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;
//下面这一坨就是Runstatue变量的值，表示线程运行的状态
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;
//阻塞队列
private final BlockingQueue<Runnable> workQueue;
//定义一个ReentrantLock对象，重入锁
private final ReentrantLock mainLock = new ReentrantLock();
//Worker集合，表示正在运行的线程集合
private final HashSet<Worker> workers = new HashSet<Worker>();
//继承了AQS，里面的条件队列
private final Condition termination = mainLock.newCondition();
//池子里面最大存放的线程数
private int largestPoolSize;
//完成的任务数
private long completedTaskCount;
//线程工厂，用来创建线程
private volatile ThreadFactory threadFactory;
//处理器，当池子线程饱和同时又有新任务进来时进行的处理，可以自定义处理，默认为抛出异常
private volatile RejectedExecutionHandler handler;
//超出corepoolsize之后的线程的存活时间
private volatile long keepAliveTime;
//核心线程超时是否继续可用
private volatile boolean allowCoreThreadTimeOut;
//核心线程数
private volatile int corePoolSize;
//池子最大线程数
private volatile int maximumPoolSize;
//默认处理器，直接抛出异常
private static final RejectedExecutionHandler defaultHandler =
new AbortPolicy();
CAS方法
private boolean compareAndIncrementWorkerCount(int expect) {
return ctl.compareAndSet(expect, expect + 1);
}
private boolean compareAndDecrementWorkerCount(int expect) {
return ctl.compareAndSet(expect, expect - 1);
}
private void decrementWorkerCount() {
do {} while (! compareAndDecrementWorkerCount(ctl.get()));
}
可见ctl变量是通过CAS来操作的
构造方法其一
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;
}
没啥好说的…
内部类Worker
private final class Worker
extends AbstractQueuedSynchronizer
implements Runnable
{
private static final long serialVersionUID = 6138294804551838833L;
final Thread thread;
Runnable firstTask;
volatile long completedTasks;
Worker(Runnable firstTask) {
setState(-1);
this.firstTask = firstTask;
this.thread = getThreadFactory().newThread(this);
}
public void run() {
runWorker(this);
}
protected boolean isHeldExclusively() {
return getState() != 0;
}
protected boolean tryAcquire(int unused) {
if (compareAndSetState(0, 1)) {
setExclusiveOwnerThread(Thread.currentThread());
return true;
}
return false;
}
protected boolean tryRelease(int unused) {
setExclusiveOwnerThread(null);
setState(0);
return true;
}
public void lock() { acquire(1); }
public boolean tryLock() { return tryAcquire(1); }
public void unlock() { release(1); }
public boolean isLocked() { return isHeldExclusively(); }
void interruptIfStarted() {
Thread t;
if (getState() >= 0 && (t = thread) != null && !t.isInterrupted()) {
try {
t.interrupt();
} catch (SecurityException ignore) {
}
}
}
}
同时实现了Runnable接口，可推出Worker对象可以当成任务来进行传参。
同时继承了AQS，所以，可以进行锁的操作，加锁和释放锁
worker就代表了线程池中执行任务的线程
我理解的worker是封装了thread和task，然后执行。
普通方法
//将线程池的状态值更改为我们想要的状态，用的CAS
private void advanceRunState(int targetState) {
for (;;) {
int c = ctl.get();
if (runStateAtLeast(c, targetState) ||
ctl.compareAndSet(c, ctlOf(targetState, workerCountOf(c))))
break;
}
}
final void tryTerminate() {
for (;;) {
int c = ctl.get();
if (isRunning(c) ||
runStateAtLeast(c, TIDYING) ||
(runStateOf(c) == SHUTDOWN && ! workQueue.isEmpty()))
return;
if (workerCountOf(c) != 0) { // Eligible to terminate
interruptIdleWorkers(ONLY_ONE);
return;
}
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
if (ctl.compareAndSet(c, ctlOf(TIDYING, 0))) {
try {
terminated();
} finally {
ctl.set(ctlOf(TERMINATED, 0));
termination.signalAll();
}
return;
}
} finally {
mainLock.unlock();
}
// else retry on failed CAS
}
}
public void shutdown() {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
checkShutdownAccess();
advanceRunState(SHUTDOWN);
interruptIdleWorkers();
onShutdown(); // hook for ScheduledThreadPoolExecutor
} finally {
mainLock.unlock();
}
tryTerminate();
}
public List<Runnable> shutdownNow() {
List<Runnable> tasks;
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
checkShutdownAccess();
advanceRunState(STOP);
interruptWorkers();
tasks = drainQueue();
} finally {
mainLock.unlock();
}
tryTerminate();
return tasks;
}
private void processWorkerExit(Worker w, boolean completedAbruptly) {
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();
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);
}
}
核心方法
private void interruptWorkers() {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
for (Worker w : workers)
w.interruptIfStarted();
} finally {
mainLock.unlock();
}
}
private void interruptIdleWorkers(boolean onlyOne) {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
for (Worker w : workers) {
Thread t = w.thread;
if (!t.isInterrupted() && w.tryLock()) {
try {
t.interrupt();
} catch (SecurityException ignore) {
} finally {
w.unlock();
}
}
if (onlyOne)
break;
}
} finally {
mainLock.unlock();
}
}
final void reject(Runnable command) {
handler.rejectedExecution(command, this);
}
================================================================================================
添加工作线程执行任务
private boolean addWorker(Runnable firstTask, boolean core) {
retry:
for (;;) {
int c = ctl.get();
int rs = runStateOf(c); //第一次检查线程池的运行状态
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))
break retry;
c = ctl.get(); //第二次检查线程池的运行状态
if (runStateOf(c) != rs)
continue retry;
}
}
//解释一下上面为啥要检查两次线程池的运行状态：
//在多线程环境下，线程池的状态时刻在变化，而ctl.get()是非原子操作，很有可能刚获取了线程池状态后线程池状态就改变了。
boolean workerStarted = false; //工作线程是否开始开关
boolean workerAdded = false; //工作线程是否成功添加开关
Worker w = null;
try {
w = new Worker(firstTask); //将任务和线程封装为Worker对象
final Thread t = w.thread;
if (t != null) {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock(); //执行关键方法前用重入锁加锁
try {
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); //将上面创建好的Worker对象放入线程池中的工作集合中
int s = workers.size();
if (s > largestPoolSize)
largestPoolSize = s;
workerAdded = true;
}
} finally {
mainLock.unlock();
}
if (workerAdded) {
t.start(); //持有该任务的线程调用start方法执行任务，工作线程开始执行
workerStarted = true;
}
}
} finally {
if (! workerStarted)
addWorkerFailed(w);
}
return workerStarted;
}
================================================================================================
private void addWorkerFailed(Worker w) {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
if (w != null)
workers.remove(w); //失败了就移除工作集合中的worker对象
decrementWorkerCount();
tryTerminate();
} finally {
mainLock.unlock();
}
}
//通过getTask方法从阻塞队列中获取等待的任务，如果队列中没有任务，getTask方法会被阻塞并挂起，不会占用cpu资源
private Runnable getTask() {
boolean timedOut = false;
for (;;) {
int c = ctl.get();
int rs = runStateOf(c);
// 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?
boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
if ((wc > maximumPoolSize || (timed && timedOut))
&& (wc > 1 || workQueue.isEmpty())) {
if (compareAndDecrementWorkerCount(c))
return null;
continue;
}
try {
Runnable r = timed ?
workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
workQueue.take();
if (r != null)
return r;
timedOut = true;
} catch (InterruptedException retry) {
timedOut = false;
}
}
}
final void runWorker(Worker w) {
Thread wt = Thread.currentThread();
Runnable task = w.firstTask; //拿到worker对象里面的任务
w.firstTask = null;
w.unlock();
boolean completedAbruptly = true;
try {
// 先执行firstTask，再从workerQueue中取task(getTask())
while (task != null || (task = getTask()) != null) {
w.lock();
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(); //执行任务
} 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; //任务执行完后置空，方便GC
w.completedTasks++;
w.unlock();
}
}
completedAbruptly = false;
} finally {
processWorkerExit(w, completedAbruptly);
}
}
==============================================================================================
该方法是进入线程池的开头方法，定义的就是任务进来线程池后的处理方式
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
int c = ctl.get();
if (workerCountOf(c) < corePoolSize) { //如果当前线程池的工作线程数小于核心线程数就添加线程来执行该任务
if (addWorker(command, true))
return;
c = ctl.get();
}
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);
}
四、总结
1、ThreadPoolExecutor这个类用来进行线程池接受任务和线程执行的逻辑处理，如果要和Executor比较的化，从范围来看，Executor是一个大的范围，它不考虑线程池内部的处理逻辑，而是能够实现业务逻辑，创建符合业务逻辑的一个线程池即可；而ThreadPoolExecutor是一个小范围，可以说是Executor内部的实现，它注重的是线程池内部的代码逻辑，线程的调度和任务的调度。
2、ThreadPoolExecutor也是可以用于多线程环境的，它的方法大量的使用ReentrantLock可重入锁来进行加锁和释放锁，同时，ctl属性使用了CAS原子操作来保证数据的一致性；另外，少量地方的属性用到了volatile关键字修饰，保证了属性的可见性。
3、ThreadPoolExecutor中的方法基本上基于ctl这个属性来进行条件的判断，ctl的高三位是保存的RunState（运行状态），低29位保存的是线程池中的线程数
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
