线程池ThreadPoolExecutor源码分析

又是美好的一天呀~
个人博客地址： huanghong.top

线程池ThreadPoolExecutor源码分析

构造方法

• corePoolSize核心线程数
• maximumPoolSize最大线程数
• keepAliveTime等待工作的空闲线程的超时时间
• unit空闲时间单位
• workQueue阻塞队列
• threadFactory线程工厂
• handler拒绝策略

//java.util.concurrent.ThreadPoolExecutor#ThreadPoolExecutor(int, int, long, java.util.concurrent.TimeUnit, java.util.concurrent.BlockingQueue<java.lang.Runnable>, java.util.concurrent.ThreadFactory, java.util.concurrent.RejectedExecutionHandler)
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;
}

成员属性

//ctl 是一个打包两个概念字段的原子整数
//workerCount：指示线程的有效数量
//runState：指示线程池的运行状态，有 RUNNING、SHUTDOWN、STOP、TIDYING、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 is stored in the high-order bits
//对应的高3位值是111
private static final int RUNNING    = -1 << COUNT_BITS;
//对应的高3位值是000
private static final int SHUTDOWN   =  0 << COUNT_BITS;
//对应的高3位值是001
private static final int STOP       =  1 << COUNT_BITS;
//对应的高3位值是010
private static final int TIDYING    =  2 << COUNT_BITS;
//对应的高3位值是011
private static final int TERMINATED =  3 << COUNT_BITS;

// Packing and unpacking ctl
//获取runState：指示线程池的运行状态，有 RUNNING、SHUTDOWN、STOP、TIDYING、TERMINATED 等状态
private static int runStateOf(int c)     { return c & ~CAPACITY; }
//获取workerCount：指示线程的有效数量
private static int workerCountOf(int c)  { return c & CAPACITY; }
private static int ctlOf(int rs, int wc) { return rs | wc; }

内部类Worker

Worker 是 ThreadPoolExecutor的一个内部类，主要是用来维护线程执行任务的中断控制状态，它实现了Runnable 接口同时继承了AQS，实现 Runnable 接口意味着 Worker 就是一个线程，继承 AQS 是为了实现独占锁这个功能。

private final class Worker extends AbstractQueuedSynchronizer implements Runnable{
    /**
     * This class will never be serialized, but we provide a
     * serialVersionUID to suppress a javac warning.
     */
    private static final long serialVersionUID = 6138294804551838833L;

    /** Thread this worker is running in.  Null if factory fails. */
    //实例封装的线程对象
    final Thread thread;
    /** Initial task to run.  Possibly null. */
    //任务
    Runnable firstTask;
    /** Per-thread task counter */
    //完成任务的数量
    volatile long completedTasks;

    /**
     * Creates with given first task and thread from ThreadFactory.
     * @param firstTask the first task (null if none)
     */
    Worker(Runnable firstTask) {
        setState(-1); // inhibit interrupts until runWorker
        this.firstTask = firstTask;
        this.thread = getThreadFactory().newThread(this);
    }

    /** Delegates main run loop to outer runWorker  */
    public void run() {
        runWorker(this);
    }

    // Lock methods
    //
    // The value 0 represents the unlocked state.
    // The value 1 represents the locked state.

    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) {
            }
        }
    }
}

提交线程任务执行流程

execute

//java.util.concurrent.ThreadPoolExecutor#execute
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)
            //工作线程为0，创建一个非核心线程，防止存在有任务但是没有线程执行的情况
            addWorker(null, false);
    }
    //当向队列添加任务失败后，则直接再创建新的线程运行，如果不能再创建线程了，则执行拒绝策略
    else if (!addWorker(command, false))
        reject(command);
}

addWorker

//java.util.concurrent.ThreadPoolExecutor#addWorker
private boolean addWorker(Runnable firstTask, boolean core) {
    //为确保线程安全，进行CAS反复重试
    retry:
    for (;;) {
        int c = ctl.get();
        // 获取runState , c 的高位存储
        // c & ~CAPACITY;
        int rs = runStateOf(c);

        //1. rs > SHUTDOWN （线程池状态处于STOP、TIDYING、TERMINATED，添加工作线程失败）
        //2.rs >= SHUTDOWN && firstTask != null 
        //3.rs >= SHUTDOWN && workQueue.isEmpty()
        // 在这三种情况下，都不会再创建新的线程
        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;
            //CAS 更新worker+1数，成功则说明占位成功退出retry，后续的添加操作将是安全的，失败则说明已有其他线程变更该值
            if (compareAndIncrementWorkerCount(c))
                break retry;
            c = ctl.get();  // Re-read ctl
            //runState 变更，则退出到retry重新循环 
            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 {
        //构建一个Worker实例
        w = new Worker(firstTask);
        final Thread t = w.thread;
        if (t != null) {
            final ReentrantLock mainLock = this.mainLock;
            //添加worker过程利用线程池中的lock对象保证线程安全
            mainLock.lock();
            try {
                // Recheck while holding lock.
                // Back out on ThreadFactory failure or if
                // shut down before lock acquired.
                int rs = runStateOf(ctl.get());
				// SHUTDOWN情况下还是会创建 Worker, 但是后续检测将会失败
                if (rs < SHUTDOWN ||
                    (rs == SHUTDOWN && firstTask == null)) {
                    //新添加的线程如果是alive状态，则抛出异常
                    if (t.isAlive()) // precheck that t is startable
                        throw new IllegalThreadStateException();
                    //添加进本地缓存
                    workers.add(w);
                    int s = workers.size();
                    //维护一个全局达到过的最大线程数计数器
                    if (s > largestPoolSize)
                        largestPoolSize = s;
                    workerAdded = true;
                }
            } finally {
                mainLock.unlock();
            }
            //启动work获取任务
            if (workerAdded) {
                t.start();
                workerStarted = true;
            }
        }
    } finally {
        //如果任务启动失败，则必须进行清理，返回失败
        if (! workerStarted)
            addWorkerFailed(w);
    }
    return workerStarted;
}

runWorker

//java.util.concurrent.ThreadPoolExecutor#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 {
        //循环从队列中获取任务
        while (task != null || (task = getTask()) != null) {
            //执行过程中同时只能一个task在运行，此时也不允许进行 interrupt
            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
            //检测是否已被线程池是否停止或者当前worker被中断
            if ((runStateAtLeast(ctl.get(), STOP) ||
                 (Thread.interrupted() &&
                  runStateAtLeast(ctl.get(), STOP))) &&
                !wt.isInterrupted())
                wt.interrupt();
            try {
                //执行任务前置扩展
                beforeExecute(wt, task);
                Throwable thrown = null;
                try {
                    //执行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

//java.util.concurrent.ThreadPoolExecutor#getTask
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.
        //如果进行了shutdown, 且队列为空, 则需要将worker退出
        if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
            decrementWorkerCount();
            return null;
        }

        int wc = workerCountOf(c);

        // Are workers subject to culling?
        boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
		//线程数据大于最大允许线程，需要删除多余的 Worker
        if ((wc > maximumPoolSize || (timed && timedOut))
            && (wc > 1 || workQueue.isEmpty())) {
            if (compareAndDecrementWorkerCount(c))
                return null;
            continue;
        }

        try {
            //允许核心线程超时结束 || 工作线程数量大于核心线程数量，则超时结束线程
            //否则进行take阻塞
            Runnable r = timed ?
                workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
                workQueue.take();
            if (r != null)
                return r;
            //如果有超时设置，则会在下一循环时退出
            timedOut = true;
        } catch (InterruptedException retry) {
            timedOut = false;
        }
    }
}

tryTerminate

//java.util.concurrent.ThreadPoolExecutor#tryTerminate
final void tryTerminate() {
    for (;;) {
        int c = ctl.get();
        //线程池是否需要终止
        //如果以下3中情况任一为true，不进行终止
        //1. 还在运行状态
        //2. 状态是TIDYING、或 TERMINATED，已经终止过了
        //3. SHUTDOWN 且 workQueue不为空
        if (isRunning(c) ||
            runStateAtLeast(c, TIDYING) ||
            (runStateOf(c) == SHUTDOWN && ! workQueue.isEmpty()))
            return;
        //只有shutdown状态且workQueue为空，或者stop状态能执行到这一步
        //如果此时线程池还有线程（正在运行任务，正在等待任务）
        //中断唤醒一个正在等任务的空闲worker
        //唤醒后再次判断线程池状态，会return null，进入processWorkerExit()流程
        if (workerCountOf(c) != 0) { // Eligible to terminate
            interruptIdleWorkers(ONLY_ONE);
            return;
        }
		//如果状态是SHUTDOWN，workQueue也为空了，正在运行的worker也没有了，开始terminated
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            //将线程池的ctl变成TIDYING（所有的任务被终止，workCount为0，为此状态时将会调用terminated()方法）
            //期间ctl有变化就会失败，会再次for循环
            if (ctl.compareAndSet(c, ctlOf(TIDYING, 0))) {
                try {
                    //子类实现
                    terminated();
                } finally {
                    //将线程池的ctl变成TERMINATED
                    ctl.set(ctlOf(TERMINATED, 0));
                    //唤醒调用了 等待线程池终止的线程awaitTermination() 
                    termination.signalAll();
                }
                return;
            }
        } finally {
            mainLock.unlock();
        }
        // else retry on failed CAS
    }
}

感谢阅读完本篇文章！！！
个人博客地址： huanghong.top