ThreadPoolExecutor线程池源码分析

ThreadPoolExecutor线程池

重要成员

/**
 * 线程池的状态变量是用一个原子整型封装了有效的线程个数workerCount和运行状态runState。
 * workerCount最大是(2^29)-1个，大约500million，指的是能够运行但不能停止的线程个数。
 * runState提供了生命周期控制：
 * RUNNING: 接受新任务，处理排队中的任务；
 * SHUTDOWN: 不接受新任务，但是能够处理排队中的任务；
 * STOP: 不接受新任务，也不处理排队中的任务，并且会中断正在执行的任务；
 * TIDYING: 所有任务已经终止，workerCount为零，线程切换到TIDYING状态，并回调钩子函数
 * terminated()；
 * TERMINATED: terminated方法完成。
 */
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存放在ctl的高3位字节
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;
//包装、解包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; }
private static boolean isRunning(int c) { return c < SHUTDOWN; }
private static boolean runStateAtLeast(int c, int s) { return c >= s; }
//尝试使用cas修改workerCount
private boolean compareAndIncrementWorkerCount(int expect){
    return ctl.compareAndSet(expect, expect + 1);
}
private boolean compareAndDecrementWorkerCount(int expect){
    return ctl.compareAndSet(expect, expect - 1);
}
//减少workerCount，尝试终止一个线程
private void decrementWorkerCount() {
	do {} while (!compareAndDecrementWorkerCount(ctl.get()));    
}
//阻塞队列
private final BlockingQueue<Runnable> workQueue;
//访问工作队列集合需要加锁
private final ReentrantLock mainLock = new ReentrantLock();
//存放线程池中的工作线程
private final HashSet<Worker> workers = new HashSet<Worker>();
//支持awaitTermination的wait条件
private final Condition termination = mainLock.newCondition();
//跟踪最大的线程池大小
private int largestPoolSize;
//已完成任务的计数器
private int completedTaskCount;
//创建新线程的工厂，使用ThreadFactory创建线程
private volatile ThreadFactory threadFactory;
//当执行中饱和或关闭时调用的处理程序
private volatile RejectedExecutionHandler handler;
//空闲线程等待工作的超时时间
private volatile long keepAliveTime;
//核心线程数
private volatile int corePoolSize;
//最大线程数
private volatile int maximumPoolSize;
//默认false，核心线程空闲时也能保活；如果为true，核心线程使用keepAliveTime等待超时
private volatile boolean allowCoreThreadTimeOut;
//默认拒绝处理器
private static final RejectedExecutionHandler defaultHandler = new AbortPolicy();

状态转换图

构造函数

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.acc = System.getSecurityManager() == null?null:AccessController.getContext();
    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{
	//执行任务的线程
    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(){
        //0表示解锁状态，1表示锁定状态
        return getState() != 0;
    }
    
    //尝试获取锁
    protected boolean tryAcquire(int unused){
        if(compareAndSetState(0, 1)){
            setExclusiveOwerThread(Thread.currentThread());
            return true;
        }
        return false;
    }
    
    //尝试释放锁
    protected boolean tryRelease(int unused){
        setExclusiveOwerThread(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){}
        }
    }
}

/**
 * 拒绝任务抛出异常
 */
public static class AbortPolicy implements RejectedExecutionHandler {
    public AbortPolicy() {}
    
    public void rejectedExecution(Runnable r, ThreadPoolExecutor e){
        throw new RejectedExecutionException("Task " + r.toString() +
                                                 " rejected from " +
                                                 e.toString());
    }
}

/**
 * 拒绝任务不抛出异常
 */
public static class DiscardPolicy implements RejectedExecutionHandler {
    public DiscardPolicy() { }
    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
    }
}

/**
 * 拒绝任务丢弃最早未处理的请求，然后重新执行
 */
public static class DiscardOldestPolicy implements RejectedExecutionHandler {
    public DiscardOldestPolicy() { }

    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
        if (!e.isShutdown()) {
            e.getQueue().poll();
            e.execute(r);
        }
    }
}

/**
 * 拒绝任务，然后调用方进行处理
 */
public static class CallerRunsPolicy implements RejectedExecutionHandler {
    public CallerRunsPolicy(){}
    
    public void rejectedExecution(Runnable r, ThreadPoolExecutor e){
        if(!e.isShutdown()){
            r.run();
        }
    }
}

重要方法

/**
 * 提交任务，带有返回值
 */
public <T> Future<T> submit(Callable<T> task){
    if(task == null) throw new NullPointerException();
    RunnableFuture<T> ftask = newTaskFor(task);
    execute(ftask);
    return ftask;
}

protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable){
    return new FutureTask<T>(callable);
}

/**
 * 在未来的某个时间执行给定任务
 */
public void execute(Runnable command){
    if(command == null)
        throw new NullPointerException();
    int c = ctl.get();
    if(workerCountOf(c) < corePoolSize){
        if(addWorker(command, true) < corePoolSize)
            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);
}

/**
 * 依据当前线程池状态和给定边界检查是否能够添加任务
 * core如果为true，则使用corePoolSize为边界，否则使用maximumPoolSize。
 */
private boolean addWorker(Runnable firstTask, boolean core){
    retry:
    for(;;){
        int c = ctl.get();
        int rs = runStateOf(c);
        //在线程池非运行状态时，只有在SHUTDOWN时，任务为空，工作队列不为空才能添加
        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;
            //重新读取ctl
            c = ctl.get();
            if(runStateOf(c) != rs)
                continue retry;
        }
    }
    
    boolean workerStarted = false;
    boolean workerAdded = false;
    Worker w = false;
    try {
        w = new Worker(firstTask);
        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())
                        throw new IllegalThreadStateException();
                    workers.add(w);
                    int s = workers.size();
                    if(s > largestPoolSize)
                        largestPoolSize = s;
                    workerAdded = true;
                }
            } finally{
            	mainLock.unlock();    
            }
            if(workerAdded){
                t.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);
        decrementWorkerCount();
        tryTerminate();
    } finally {
        mainLock.unlock();
    }
}

/**
 * 工作线程主循环
 */
final void runWorker(Worker w) {
    Thread wt = Thread.currentThread();
    Runnable task = w.firstTask;
    w.firstTask = null;
    w.unlock(); //允许中断
    boolean completedAbruptly = true;
    try {
        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 new Error(x);
                } finally {
                    afterExecute(task, thrown);
                }
            } finally {
                task = null;
                w.completedTasks++;
                w.unlock();
            }
        }
        completedAbruptly = false;
    } finally {
        processWorkerExit(w, completedAbruptly);
    }
}

/**
 * 获取任务
 */
private Runnable getTask() {
    boolean timedOut = false;
    
    for(;;){
    	int c = ctl.get();
        int rs = runStateOf(c);
        //非运行状态并且不是SHUTDOWN状态或者阻塞队列为空
        if(rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())){
            decrementWorkerCount();
            return null;
        }
        
        int wc = workerCountOf(c);
        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;
        }
    }
}

//执行清理,completedAbruptly为true表示因为用户异常导致工作线程死亡
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;
        }
        addWorker(null, false);
    }
}

final void tryTerminated() {
    for(;;) {
        int c = ctl.get();
        if(isRunning(c) ||
            runStateAtLeast(c, TIDYING) ||
            (runStateOf(c) == SHUTDOWN && !workQueue.isEmpty())) 
            return;
        if(workerCountOf(c) != 0) {
            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();
                }
            }
        } finally {
            mainLock.unlock();
        }
    }
}

//onlyOne为true,最多中断一个线程
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;
            }
        }
    }
}

/**
 * 移除任务
 */
private static void remove(Runnable task){
    boolean removed = workQueue.remove(task);
    tryTerminate();
    return removed;
}

/**
 * 拒绝任务
 */
final void reject(Runnable command) {
    handler.rejectedExecution(command, this);
}