由淺入深瞭解線程池之源碼初探

前面初步瞭解了下線程池，包括如何定義一個線程池,線程池的常用構造參數以及jdk的默認實現,今天想結合源碼來聊一聊線程池加載任務的順序、線程池如何回收線程等問題;

前置知識瞭解

ctl參數

• private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
    一個線程安全的Integer參數,其維護了兩個參數,其高三位表示線程池的狀態,低29位表示有效(活躍)線程數((2^29)-1)

線程池的狀態

• RUNNING
    線程池的初始狀態，表示正在運行,可以正常接收任務、處理已添加過的任務；
• SHUTDOWN
    不再接收新任務,但是還能處理已經添加的任務；調用shutdown方法進入此狀態
• STOP
    不再接收新任務,也不處理已添加的任務,並且會嘗試中斷正在處理的任務，調用shutdownNow()進入此狀態
• TIDYING
    當所有的任務已終止，ctl記錄的活躍線程個數爲0時線程池會變爲TIDYING狀態。當線程池變爲TIDYING狀態時，會執行鉤子函數terminated()。terminated()方法可以重寫自定義其執行內容；當線程池在SHUTDOWN狀態下，阻塞隊列爲空並且線程池中執行的任務也爲空時，就會由SHUTDOWN變爲TIDYING，當線程池在STOP狀態下並且線程池中執行的任務爲空時，就會由STOP變爲TIDYING。
• TERMINATED
    表示線程池徹底終止；在TIDYING狀態回調完可以通過重載terminated方法後進入

源碼初探

構造方法

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;
        // 將keepAliveTime轉換成納秒
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

構造方法就進行了一些校驗和賦值操作

execute方法

public void execute(Runnable command) {
        if (command == null)
            throw new NullPointerException();
        // ctl是一個線程安全的Integer，共32位,高3位表示線程池狀態，低29位表示活躍線程數的個數；
        int c = ctl.get();
        // 如果活躍線程的個數小於核心線程,則直接創建線程執行任務
        if (workerCountOf(c) < corePoolSize) {
            if (addWorker(command, true))
                return;
            c = ctl.get();
        }
        // 如果線程池是RUNNING且當前任務可以成功加入任務隊列,在雙重check後則嘗試加入線程池執行
        if (isRunning(c) && workQueue.offer(command)) {
            /**
             * 重新獲取ctl並再次檢查線程池狀態是爲了防止併發環境下，command(任務)加入隊列後線程池的狀態可能由RUNNING改爲STOP或
             * SHUTDOWN。當這種情況發生時需要將任務從任務隊列移除並且拒絕
             */
            int recheck = ctl.get();
            if (! isRunning(recheck) && remove(command))
                reject(command);
            // 如果線程池的活躍線程數爲0了,則向池內添加非核心線程任務(由於核心線程允許爲0所以會存在活躍線程爲0的情況)
            else if (workerCountOf(recheck) == 0)
                addWorker(null, false);
        }
        // 如果線程池不是RUNNING狀態或者加入隊列失敗了,這時會嘗試直接向池內添加線程任務；如果addWorker失敗則直接拒絕
        else if (!addWorker(command, false))
            reject(command);
    }

execute方法指明瞭線程池執行任務順序的大致方向,做了一些線程狀態的校驗拒絕工作,但是真正幹活的還是下面addWorker方法

worder類

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;

        /** 執行任務的線程 */
        final Thread thread;
        /** 線程需要執行的任務,可能爲null */
        Runnable firstTask;
        /** 完成的任務數 */
        volatile long completedTasks;

        /**
         * 構建Worker(addWorker方法裏添加worker時會調用)
         * @param firstTask the first task (null if none)
         */
        Worker(Runnable firstTask) {
            // 設置AQS的state爲-1(即同步狀態)
            setState(-1); // inhibit interrupts until runWorker
            // 給任務賦值
            this.firstTask = firstTask;
            // 通過線程工廠創建執行任務的線程
            this.thread = getThreadFactory().newThread(this);
        }

        /** 重寫Runnable裏的run方法  */
        public void run() {
            runWorker(this);
        }


        /**
         * 是否獲取到鎖
         * 0表示處於未被鎖定狀態
         * 1表示被鎖定狀態
         * @return
         */
        protected boolean isHeldExclusively() {
            return getState() != 0;
        }

        /**
         * 使用AQS設置線程狀態
         * @param unused
         * @return
         */
        protected boolean tryAcquire(int unused) {
            if (compareAndSetState(0, 1)) {
                setExclusiveOwnerThread(Thread.currentThread());
                return true;
            }
            return false;
        }

        /**
         * 釋放鎖
         * @param unused
         * @return
         */
        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) {
                }
            }
        }
    }

Worker類既繼承了AQS又實現了Runnable接口,所以使其既是一個同步器又是一個線程類

addWorker方法

private boolean addWorker(Runnable firstTask, boolean core) {
        retry:
        for (;;) {
            // 獲取線程狀態
            int c = ctl.get();
            int rs = runStateOf(c);
            /*******************************第一部分(校驗線程池當前狀態是否能新增線程任務)**********************/
            /**
             * rs >= SHUTDOWN 表示STOP、TIDYING、TERMINATED狀態
             * !(rs == SHUTDOWN && firstTask == null && ! workQueue.isEmpty())表示三者只要有一個不成立則條件成立
             * 總結：
             * 1、當rs是非RUNNING狀態直接返回false
             * 2、當rs是非RUNNING狀態且firstTask不等於空時返回false;
             * 3、當rs是非RUNNING狀態且workQueue等於空時返回false;
             * 此處自己琢磨半天總結,如有錯誤還望大佬指正
             */
            if (rs >= SHUTDOWN &&
                ! (rs == SHUTDOWN &&
                   firstTask == null &&
                   ! workQueue.isEmpty()))
                return false;

            for (;;) {
                // 獲取線程池的活躍線程數
                int wc = workerCountOf(c);
                // 如果線程池的活躍線程數大於線程池的最大容量CAPACITY(536870911)或者大於等於核心線程數或最大線程數時返回false
                if (wc >= CAPACITY ||
                    wc >= (core ? corePoolSize : maximumPoolSize))
                    return false;
                // 通過cas添加活躍線程數量,添加成功則認爲當前環境允許添加線程任務所以跳過校驗直接進行添加和執行的操作
                if (compareAndIncrementWorkerCount(c))
                    break retry;
                c = ctl.get();  // Re-read ctl
                if (runStateOf(c) != rs)
                    continue retry;
                // cas失敗則繼續內存自旋直到成功爲止
            }
        }
        /*******************************第二部分(校驗通過進行添加和執行線程的操作)**********************/
        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 {
                    // 再次獲取線程池的狀態並檢查
                    int rs = runStateOf(ctl.get());
                    /**
                     * 當線程池的狀態爲RUNNING或者是SHUTDOWN但是任務爲空則進行添加活躍(工作)線程操作
                     */
                    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;
    }

addWorker方法定義瞭如何將線程任務添加到線程池中去並執行

runWorker方法

final void runWorker(Worker w) {
        Thread wt = Thread.currentThread();
        Runnable task = w.firstTask;
        w.firstTask = null;
        // 設置state=0調用tryRelease嘗試釋放鎖,允許中斷任務的執行
        w.unlock(); // allow interrupts
        // 下面的循環出現異常則該值爲true否則會被值爲false
        boolean completedAbruptly = true;
        try {
            // 如果task不爲null，或者task爲空但是從任務隊列裏能取到任務則一直循環取出任務並執行
            while (task != null || (task = getTask()) != null) {
                // 加鎖；
                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
                /**
                 * 如果線程池正在被終止(處於STOP/TIDYING/TERMINATED狀態),則需要確保線程被中斷
                 * 如果線程池爲RUNNING/SHUTDOWN狀態則清楚中斷狀態
                 */
                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;
                    // 完成任務數加1
                    w.completedTasks++;
                    w.unlock();
                }
            }
            completedAbruptly = false;
        } finally {
            /**
             * 線程退出
             * 如果completedAbruptly=true表示task.run()出了異常,如果如果completedAbruptly=false
             * 表示while循環拿不到任務了
             */
            processWorkerExit(w, completedAbruptly);
        }
    }

runWorker方法不斷循環從隊列裏取任務並執行,

線程池加載任務的順序

  結合上面的execute方法我們大概可以得出線程池加載任務的順序：

• 嘗試開啓核心線程並執行任務
• 如果核心線程數已經達標並且線程池是RUNNING狀態則嘗試加任務加入任務隊列
• 如果線程池不是RUNNING狀態或者加入隊列失敗了,這時會嘗試直接向池內添加線程任務；如果addWorker失敗則直接拒絕；添加失敗的原因有可能是達到了線程池的最大線程數也有可能是線程池處於非RUNNING

線程池如何回收線程

• RUNNING狀態下
  在RUNNING狀態下可以通過上面的runWorker來進行分析,噹噹前執行的任務爲空或者任務隊列裏沒有任務時會進行工作線程回收
• SHUTDOWN狀態下
  在調用shutdown()之後，會向所有的空閒工作線程發送中斷信號

一些感悟

  差不多兩天時間的源碼讀下來越發有種矇蔽的感覺,線程池涉及的知識點還是比較廣泛的,包括AQS、多線程的知識、CAS等等,此篇博文暫且先到這了，其中不完善的地方只能後續慢慢學習補充了，不過從源碼中倒是讓我學到了一個編碼小技巧，
就是當你的代碼裏有多個變量需要同時進行判斷時,並不用讓變量一字排開進行或、與的操作,而是對變量進行巧妙的設計，將這些變量定義成整形,相互之間的大小根據業務需求來定,然後可能就一個範圍的判斷即可替代之前的一堆或與操作了