ThreadPoolExecutor源码解析一

属性

// 用于存放线程池状态(前3位)+工作线程数(后29位)
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));

// 29位
private static final int COUNT_BITS = Integer.SIZE - 3;

// 线程池的最大线程数容量 0001 1111 1111 1111 1111 1111 1111 1111
private static final int CAPACITY   = (1 << COUNT_BITS) - 1;


// 运行:接收新任务,处理队列中的任务 1110 0000 0000 0000 0000 0000 0000 0000
private static final int RUNNING    = -1 << COUNT_BITS;

// 关机:不接收新任务,但处理队列中的任务 0000 0000 0000 0000 0000 0000 0000 0000
private static final int SHUTDOWN   =  0 << COUNT_BITS;

// 停止:不接收新任务,也不处理队列中的任务,并且终端正在进行中的任务 0001 0000 0000 0000 0000 0000 0000 0000
private static final int STOP       =  1 << COUNT_BITS;

// 整理:所有任务终止,队列中的任务数量为0,此时线程转换为TIDYING状态,将会执行terminated()方法
private static final int TIDYING    =  2 << COUNT_BITS;

// 终止:terminated()方法执行完成
private static final int TERMINATED =  3 << COUNT_BITS;

线程状态相关方法

//  CAPACITY值为:0001 1111 1111 1111 1111 1111 1111 1111
// ~CAPACITY值为:1110 0000 0000 0000 0000 0000 0000 0000

// 线程当前状态,int c 为线程状态+工作线程数,&操作将低29位置0,获取线程当前状态
private static int runStateOf(int c)     { return c & ~CAPACITY; }

// 工作线程数,int c 为线程状态+工作线程数,&操作将高3位置0,获取工作线程数
private static int workerCountOf(int c)  { return c & CAPACITY; }

// 将线程当前状态和工作线程数合并在一起
private static int ctlOf(int rs, int wc) { return rs | wc; }

// 判断c是否小于s
// int c入参一般为,当前线程的(线程状态+工作线程数),int s入参一般 为常量:RUNNING,SHUTDOWN,STOP,TIDYING,TERMINATED
private static boolean runStateLessThan(int c, int s) {
    return c < s;
}

// 判断c是否大于等于s
// int c入参一般为,当前线程的(线程状态+工作线程数),int s入参一般 为常量:RUNNING,SHUTDOWN,STOP,TIDYING,TERMINATED
private static boolean runStateAtLeast(int c, int s) {
    return c >= s;
}

// 判断是否为 RUNNING状态
private static boolean isRunning(int c) {
    return c < SHUTDOWN;
}

// CAS操作,尝试将工作线程数加一
private boolean compareAndIncrementWorkerCount(int expect) {
    return ctl.compareAndSet(expect, expect + 1);
}

// CAS操作,尝试将工作线程数减一
private boolean compareAndDecrementWorkerCount(int expect) {
    return ctl.compareAndSet(expect, expect - 1);
}

// 线程突然终止时,CAS减少工作线程数
private void decrementWorkerCount() {
    do {} while (! compareAndDecrementWorkerCount(ctl.get()));
}

相关属性

// 保存任务的阻塞队列
private final BlockingQueue<Runnable> workQueue;

// 锁
private final ReentrantLock mainLock = new ReentrantLock();

// 包含所有工作线程,持有mainLock才可访问
private final HashSet<ThreadPoolExecutor.Worker> workers = new HashSet<ThreadPoolExecutor.Worker>();

// 等待条件支持awaittermination
private final Condition termination = mainLock.newCondition();

// 最大的池大小,持有mainLock才可访访问
private int largestPoolSize;

// 已完成任务计数,仅在工作线程终止时更新,持有mainLock才可访访问
private long completedTaskCount;

// 线程工厂
private volatile ThreadFactory threadFactory;

// 拒绝策略
private volatile RejectedExecutionHandler handler;

// 线程从队列中获取任务的超时时间
private volatile long keepAliveTime;

// 如果为false(默认值),核心线程即使在空闲时也保持活动.如果为true,核心线程使用keepAliveTime超时等待工作。
private volatile boolean allowCoreThreadTimeOut;

// 核心线程数
private volatile int corePoolSize;

// 最大线程数
private volatile int maximumPoolSize;

构造方法

// 核心线程数,最大线程数,保持时间,保持时间的单位,存放任务的队列
public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue) {
    this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
            Executors.defaultThreadFactory(), defaultHandler);
}

// 核心线程数,最大线程数,保持时间,保持时间的单位,存放任务的队列,线程工厂
public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory) {
    this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
            threadFactory, defaultHandler);
}

// 核心线程数,最大线程数,保持时间,保持时间的单位,存放任务的队列,拒绝策略
public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          RejectedExecutionHandler handler) {
    this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
            Executors.defaultThreadFactory(), handler);
}

// 核心线程数,最大线程数,保持时间,保持时间的单位,存放任务的队列,线程工厂,拒绝策略
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;
}

execute()

// 1.如果正在运行的线程少于corePoolSize，尝试用给定的命令作为第一个任务来启动一个新线程。对addWorker的调用会自动检查runState和workerCount，并通过返回false来防止在不应该添加线程时出现假警报。
// 2.如果一个任务可以成功地进入队列，那么我们仍然需要再次检查是否应该添加一个线程(因为在上次检查之后已有的线程死掉了)，或者在进入这个方法之后池关闭了。因此，我们重新检查状态，并在必要时在停止时回滚排队，或者在没有线程时启动一个新线程。
// 3.如果不能对任务进行排队，则尝试添加一个新线程。如果它失败了，我们知道我们被关闭或饱和，所以拒绝任务。

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();
    }
    
    // 线程池处于RUNNING状态,并且任务队列未满
    if (isRunning(c) && workQueue.offer(command)) {
        int recheck = ctl.get();
        // 不是运行状态,则从workQueue中移除任务,并执行拒绝策略
        if (! isRunning(recheck) && remove(command))
            reject(command);
        // 线程池处于RUNNING状态 或者 线程池处于非RUNNING状态但是任务移除失败
        else if (workerCountOf(recheck) == 0)
        // 如果工作线程数为0,则添加一个null任务
        // 此处作用是,当线程池状态为SHUTDOWN状态,队列里面还有任务未执行时,需要添加一个线程,执行队列中的剩余任务
            addWorker(null, false);
    }
    // 线程池处于非RUNNING状态 或者任务队列满了,以最大线程数为界限,创建新的worker
    // 如果失败,则执行拒绝策略
    else if (!addWorker(command, false))
        reject(command);
}

addWorker()

// firstTask:待添加任务,core:是否为核心线程数
private boolean addWorker(Runnable firstTask, boolean core) {
    retry:
    // 双重for循环的主要作用为:判断状态,增加线程数
    for (;;) {
    	// 获取线程状态和线程数
        int c = ctl.get();
        // 获取线程状态
        int rs = runStateOf(c);


        if (
        		// 如果线程状态为:RUNNING,则往下执行
        		// 如果线程状态为:SHUTDOWN,STOP,TIDYING,TERMINATED,则继续判断
        		rs >= SHUTDOWN && 
        		// 只要括号中有一个false,则添加失败
                ! (
                	// 如果线程状态不为:SHUTDOWN ,即线程状态可能为:STOP,TIDYING,TERMINATED,表达式为false,添加失败
                	// 如果线程状态为:SHUTDOWN(不接收任务,但处理队列中的任务),继续判断
                	rs == SHUTDOWN
                	// 任务不为空,表达式为false,添加失败(前置条件线程状态为SHUTDOWN,不接收任务,但处理队列中的任务)
                	// 任务为空,继续判断
                	&& firstTask == null
                	// 如果任务队列为空,表达式为false,添加失败
                	// (前置条件中,firstTask == null,此时没有需要执行的任务,并且任务队列也为空,所以不需要添加线程,直接return
                	// 如果任务队列不为空,则往下执行
                	&& ! 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();
            
            // 判断线程状态是否被改变
            if (runStateOf(c) != rs)
                continue retry;
        }
    }
	
	
	// 程序执行到此处,说明workerCount线程数已经加1
	
    boolean workerStarted = false;
    boolean workerAdded = false;
    ThreadPoolExecutor.Worker w = null;
    try {
        w = new ThreadPoolExecutor.Worker(firstTask);
        final Thread t = w.thread;
        if (t != null) {
            final ReentrantLock mainLock = this.mainLock;
            // 加锁
            mainLock.lock();
            try {
                int rs = runStateOf(ctl.get());
				// 线程状态为RUNNING状态 或者为SHUTDOWN状态,并且待添加任务为空
                if (rs < SHUTDOWN ||
                        (rs == SHUTDOWN && firstTask == null)) {
                    
                    // 预先检查t是否可启动  
                    if (t.isAlive())
                        throw new IllegalThreadStateException();
                    workers.add(w);
                    
                    int s = workers.size();
                    // 当前线程池大小与最大池大小比较
                    if (s > largestPoolSize)
                        largestPoolSize = s;

                    // worker添加成功
                    workerAdded = true;
                }
            } finally {
                mainLock.unlock();
            }
            if (workerAdded) {
                t.start();
                // 线程启动成功
                workerStarted = true;
            }
        }
    } finally {
        if (! workerStarted)
        	// 线程启动失败,从workers中移除w,并且递减workerCount,会除法tryTerminate()方法
            addWorkerFailed(w);
    }
    return workerStarted;
}

void runWorker()

// 执行任务
final void runWorker(ThreadPoolExecutor.Worker w) {
    Thread wt = Thread.currentThread();
    Runnable task = w.firstTask;
    w.firstTask = null;
    // Worker的构造函数中抑制了线程中断setState(-1),此时w.unlock()重新设置setState(0),允许中断
    w.unlock(); // allow interrupts

    // completedAbruptly为true的情况:1.执行任务抛出异常,2.被中断
    boolean completedAbruptly = true;
    try {
    // task不为空,或者从队列中取出一个任务
        while (task != null || (task = getTask()) != null) {
            w.lock();
           // 1.如果线程池正在停止,确保线程被中断
           // 2.如果没有停止，确保线程没有被中断
           // 这需要在第二种情况下重新检查,同时清除中断
            if (
		           	(
		           		// 线程状态大于等于STOP(STOP,TIDYING,TERMINATED),即线程正在停止
		           		runStateAtLeast(ctl.get(), STOP) 
		           		// (Thread.interrupted() ->isInterrupted(true))  并且再次判断线程是否正在停止
		           		|| (Thread.interrupted() && runStateAtLeast(ctl.get(), STOP))
		      		) 
		      		//	wt.isInterrupted() -> isInterrupted(false)
		      			&& !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 {
                	// 钩子函数,同beforeExecute(wt, task);
                    afterExecute(task, thrown);
                }
            } finally {
                task = null;
                // 已完成任务书加1
                w.completedTasks++;
                w.unlock();
            }
        }
        completedAbruptly = false;
    } finally {
    	// 线程清理工作
        processWorkerExit(w, completedAbruptly);
    }
}

getTask()

// 根据当前配置设置，对任务执行阻塞或定时等待，如果该worker因以下任何原因必须退出，则返回null:
// 1. 有更多的工人(由于调用setMaximumPoolSize)。
// 2. 池已停止。
// 3.池关闭，队列为空。
// 4. 这个worker超时等待一个任务，超时的worker在超时等待之前和之后都会被终止(即allowCoreThreadTimeOut || workerCount > corePoolSize)，如果队列不是空的，这个worker就不是池中的最后一个线程。
private Runnable getTask() {
    boolean timedOut = false;

    for (;;) {
        int c = ctl.get();
        int rs = runStateOf(c);

        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;
        }
    }
}

processWorkerExit()

// completedAbruptly:是否为用户异常导致
private void processWorkerExit(ThreadPoolExecutor.Worker w, boolean completedAbruptly) {
	// 如果为用户异常,例如执行任务过程中抛出异常,则减少工作线程数
    if (completedAbruptly)
		// 减少工作线程数
        decrementWorkerCount();

    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
    	// 将worker完成任务的数量,赋值给completedTaskCount(已完成任务计数,仅在工作线程终止时更新)
        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);
    }
}