ThreadPoolExecutor源码分析二

 

接上文，这里继续分析源码

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;

 

线程池有5种状态，RUNNING运行中状态；SHUTDOWN关闭中状态；STOP停止状态；TIDYING收拾整理状态；TERMINATED结束状态。

 

RUNNING状态是线程池初始化时的状态，可接收任务，可执行任务；调用方法shutdown()变成SHUTDOWN状态，调用方法shutdownNow()变成STOP状态。

SHUTDOWN状态不会再接收任务，但是会把线程中的任务和队列中的任务执行完成。任务执行完后变成TIDYINGZ状态，同时期间调用方法shutdownNow()变成STOP状态。

STOP状态不会接收任务，终止线程中的任务执行，不在执行任务队列里的任务。任务执行完后变成TIDYING状态

TIDYING状态已经不接收任务，不执行线程了。调用钩子方法terminated()后变成TERMINATED状态

TERMINATED状态是一个结束状态。

 

COUNT_BITS是一个移位标记数，值为29；

CAPACITY   = (1 << COUNT_BITS) - 1 // 32位bit，000（前三位） |  后面29为用来记录当前任务数

表示线程池当前接收的任务数最大值为(1 << COUNT_BITS) - 1

状态标记值分别为：

RUNNING    = -1 << COUNT_BITS;  // 32位bit，111（前三位）| 后面29位全部为0

SHUTDOWN   =  0 << COUNT_BITS;  // 32位bit，000（前三位）| 后面29位全部为0

STOP       =  1 << COUNT_BITS; // 32位bit，001（前三位）| 后面29位全部为0

TIDYING    =  2 << COUNT_BITS;// 32位bit，010（前三位）| 后面29位全部为0

TERMINATED =  3 << COUNT_BITS; // 32位bit，011（前三位）| 后面29位全部为0

 

这里线程池状态标记和当前任务数，使用了一个技巧，后面讲到。

 

private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));

// 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是线程池的一个标记值，同时记录线程池的状态值和当前任务数，32位中，前三位用来记录线程池的状态值，后29位用来记录当前任务数。

 

runStateOf(int c)     { return c & ~CAPACITY; } // 获得当前线程池的状态

workerCountOf(int c)  { return c & CAPACITY; } // 获得当前任务数

ctlOf(int rs, int wc) { return rs | wc; } // 构造线程池的标记值  

 

这里很技巧的使用了位运算和存储，大部分java为第一语言的人都没有这种意识。

 

//  判断ctl值c是否最少是s状态，
 private static boolean runStateLessThan(int c, int s) {
        return c < s;
  }
// 判断ctl值c至少是s状态
    private static boolean runStateAtLeast(int c, int s) {
        return c >= s;
    }
   // 判断ctl值是否是RUNNING状态
    private static boolean isRunning(int c) {
        return c < SHUTDOWN;
    }

 

从状态值能看到 RUNNING < 0 = SHUTDOWN < STOP < TIDYING < TERMINATED，任务数是存储在后29位，他的数量不会影响前面状态对应ctl值的排序。

 

    /**
     * 使用CAS方式，使ctl中的任务数加一
     */
    private boolean compareAndIncrementWorkerCount(int expect) {
        return ctl.compareAndSet(expect, expect + 1);
    }

    /**
     * 使用CAS方式，使ctl中的任务数减一
     */
    private boolean compareAndDecrementWorkerCount(int expect) {
        return ctl.compareAndSet(expect, expect - 1);
    }

    /**
     * 使用CAS方式，使ctl中的任务数减一，直到成功为止
     */
    private void decrementWorkerCount() {
        do {} while (! compareAndDecrementWorkerCount(ctl.get()));
    }

 

 

下面看看添加任务的方法：

 

public void execute(Runnable command) {
    // 校验入参的合法性
    if (command == null)
        throw new NullPointerException();

    // 获得ctl的值
    int c = ctl.get();
    // workerCountOf(c) 获得ctl中标记的任务数
    // 当前任务数小于corePoolSize数
    if (workerCountOf(c) < corePoolSize) {
        // 添加任务到执行队列，添加成功即方法结束
        if (addWorker(command, true))
            return;
        // 如果多线程竞争失败后，重新获得ctl的值，往下执行
        c = ctl.get();
    }
    // 此时执行线程数已经达到corePoolSize数
    // 判断线程池是否在运行，任务是否能成功加入到等待队列
    if (isRunning(c) && workQueue.offer(command)) {
        // 成功加入，再次获取ctl值
        int recheck = ctl.get();
        // 再次判断线程池是否在运行，如果不在运行，则移除任务，并且拒绝任务
        if (! isRunning(recheck) && remove(command))
            reject(command); // 拒绝任务
        // 如果任务数为0，表示执行线程也没有，需要添加一个null的执行任务，实际是添加一个执行线程
        else if (workerCountOf(recheck) == 0)
            addWorker(null, false); // 添加执行线程
    }
    // 任务添加队列失败，看是否可以再添加一个执行线程，执行线程数在（corePoolSize, maximumPoolSize）之间
    else if (!addWorker(command, false))
        reject(command); // 如果添加失败，也拒绝任务
}

 

上面有个方法没涉及到，就是 addWorker(Runnable firstTask, boolean core)， 下面分析下：

core是标记添加的执行线程是否是核心线程。前面介绍过两个参数corePoolSize, maximumPoolSize，corePoolSize <= maximumPoolSize ;当执行线程数小于corePoolSize时，添加任务时，core＝true；当执行线程数在corePoolSize和maximumPoolSize之间时，core＝false；当执行线程数大于maximumPoolSize时，core＝false，其实是添加不进去的

 

private boolean addWorker(Runnable firstTask, boolean core) {
    // retry循环
    retry:
    for (;;) {
        // 获得线程池ctl的值
        int c = ctl.get();
        // 获得线程池的状态
        int rs = runStateOf(c);

        // 当线程池的状态至少是停止中，且当不是（rs == SHUTDOWN &&firstTask == null && ! workQueue.isEmpty()）时，不让添加执行任务了
        // rs == SHUTDOWN &&firstTask == null && ! workQueue.isEmpty() 表示线程池状态为SHUTDOWN,且等待任务队列不为空和添加的任务为null时，还是需要执行线程来执行下面的任务，允许添加执行线程
        if (rs >= SHUTDOWN &&
            ! (rs == SHUTDOWN &&
               firstTask == null &&
               ! workQueue.isEmpty()))
            return false;
        // 无线循环
        for (;;) {
            // 当前任务数
            int wc = workerCountOf(c);
            // 当当前任务数大于最大任务阀值，或者 wc大于调用方预期的最大值时，添加失败
            if (wc >= CAPACITY ||
                wc >= (core ? corePoolSize : maximumPoolSize))
                return false;
            // 任务添加成功，增加任务数
            if (compareAndIncrementWorkerCount(c))
                break retry;// 任务数添加成功，中断循环
            // 任务数添加有竞争，添加失败，重新获取ctl的值
            c = ctl.get();  // Re-read ctl
            if (runStateOf(c) != rs)
                continue retry;
        }
    }
    // 标记执行线程是否启动
    boolean workerStarted = false;
    // 标记任务是否添加成功
    boolean workerAdded = false;
    Worker w = null;
    try {
        // 创建一个执行任务对象
        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());

                // 当线程池是RUNNING运行状态 或者  线程池是SHUTDOWN状态，任务是null，往下执行
                if (rs < SHUTDOWN ||
                    (rs == SHUTDOWN && firstTask == null)) {
                    // 线程必须保证是没有start的，这里做参数校验
                    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();
            }
            // 任务添加成功，开始执行任务线程
            if (workerAdded) {
                t.start();
                workerStarted = true;
            }
        }
    } finally {
        if (! workerStarted)
            addWorkerFailed(w);
    }
    return workerStarted;
}

 

 

这里在说明下任务对象，线程池把任务封装成一个对象 java.util.concurrent.ThreadPoolExecutor.Worker，Worker继承接口Runnable，run方法重写如下：

public void run() {
    // 任务执行线程，其实是在执行线程池的 runWorker方法
    runWorker(this);
}

 

后面分析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 {
        // 这里是一个循环，如果执行线程的任务为null，或者从任务队列中取不到任务，线程将结束
        // 任务执行完后，线程的结束与否，控制在方法getTask()中
        while (task != null || (task = getTask()) != null) {
            w.lock();
            // 如果线程池的状态是STOP，且线程还没有 interrupted, 线程需要再调用 interrupted()方法
            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;
                w.completedTasks++;
                w.unlock();
            }
        }
        completedAbruptly = false;
    } finally {
        processWorkerExit(w, completedAbruptly);
    }
}

 

最后一个方法getTask() ;

 

 private Runnable getTask() {
    // 是否超时，默认是没有超时的
    boolean timedOut = false; // Did the last poll() time out?

    for (;;) {
        // 获得线程池ctl的值
        int c = ctl.get();
        // 获得线程池的状态值
        int rs = runStateOf(c);

        // 如果线程池的状态是STOP停止状态，或者线程池的状态是停止中且任务队列为空
        if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
            // 线程任务数将减一
            decrementWorkerCount();
            return null;
        }
        // 再次获得当前任务数
        int wc = workerCountOf(c);

        // timed表示是否允许获取任务超时就停止线程的运行
        // 一种情况是用户设定允许，调用方法：allowsCoreThreadTimeOut()
        // 另一种情况是用户当前线程数大于corePoolSize
        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;
        }
    }
}