源碼如下所示：

// BlockingQueue.java
public interface BlockingQueue<E> extends Queue<E> {
    // 在不超過隊列容量的前提下女仰，將指定的元素添加到隊列中很钓，成功就返回true，如果隊列已經(jīng)滿了董栽，就拋出IllegalStateException異常，當使用有容量限制的隊列時企孩，最好還是調用offer(E e)方法
    boolean add(E e);

    // 在不超過容量的前提下锭碳，將指定的元素添加到隊列中，成功就返回true勿璃，如果隊列已經(jīng)滿了擒抛，就返回false推汽，當使用有容量限制的隊列時，調用這個方法會比add(E e)方法好
    boolean offer(E e);

    // 將指定的元素添加到隊列中歧沪，如果沒有足夠的空間歹撒，就等待
    void put(E e) throws InterruptedException;

    // 將指定的元素添加到隊列中，如果沒有足夠的空間诊胞，就等待到指定的等待時間
    boolean offer(E e, long timeout, TimeUnit unit)
        throws InterruptedException;

    // 檢索并且刪除隊列的頭元素暖夭，如果沒有足夠的空間，就等待
    E take() throws InterruptedException;

    // 檢索并且刪除隊列的頭元素撵孤，如果沒有足夠的空間迈着，就等待到指定的等待時間
    E poll(long timeout, TimeUnit unit)
        throws InterruptedException;

    // 返回隊列在理想情況下（在沒有內存或者資源約束的情況下）可以不阻塞地接受額外元素的數(shù)量，如果沒有限制邪码，就返回Integer.MAX_VALUE的值
    int remainingCapacity();

    // 如果隊列中包含一個或者多個指定的元素（通過equals方法判斷是否是同一個元素）裕菠，就刪除這些元素，并且返回true闭专，否則返回false
    boolean remove(Object o);

    // 如果隊列中包含一個或者多個指定的元素（通過equals方法判斷是否是同一個元素）奴潘，就返回true，否則返回false
    boolean contains(Object o);

    // 從隊列中刪除指定的集合c中的元素影钉，如果指定的集合c是該隊列或者該隊列的某個元素的某些屬性阻止將其添加到指定的集合中画髓，就拋出IllegalArgumentException異常，如果在執(zhí)行此操作時修改了給定的集合斧拍，則此方法的結果將未知
    int drainTo(Collection<? super E> c);

    // 從隊列中刪除指定的集合c中的數(shù)量是maxElements的元素雀扶，如果指定的集合c是該隊列或者該隊列的某個元素的某些屬性阻止將其添加到指定的集合中，就拋出IllegalArgumentException異常肆汹，如果在執(zhí)行此操作時修改了給定的集合愚墓，則此方法的結果將未知
    int drainTo(Collection<? super E> c, int maxElements);
}

看下接口BlockingQueue的實現(xiàn)類，可得知阻塞隊列有以下幾種類型：

• ArrayBlockingQueue：使用數(shù)組實現(xiàn)的有容量限制的阻塞隊列昂勉，按照先進先出（FIFO浪册，F(xiàn)irst-In-First-Out）的原則對元素進行排序，支持公平鎖和非公平鎖岗照。
• DelayQueue：實現(xiàn)延遲獲取的沒有容量限制的阻塞隊列村象，可以指定延遲時間，只有達到指定的延遲時間攒至，才能獲取該隊列中的元素厚者。
• LinkedBlockingDeque：使用雙向鏈表實現(xiàn)的阻塞隊列，隊頭和隊尾都可以添加或者刪除元素迫吐，在并發(fā)環(huán)境下库菲，可以將鎖的競爭最多降到一半。
• LinkedBlockingQueue：使用鏈表實現(xiàn)的有容量限制的阻塞隊列志膀，按照先進先出（FIFO熙宇，F(xiàn)irst-In-First-Out）的原則對元素進行排序鳖擒，默認長度是Integer.MAX_VALUE，所以默認創(chuàng)建該隊列可能有容量危險烫止，該隊列通常比基于數(shù)組實現(xiàn)的隊列具有更高的吞吐量蒋荚，但是在并發(fā)環(huán)境下，性能會比較差馆蠕。
• LinkedTransferQueue：使用鏈表實現(xiàn)的沒有容量限制的阻塞隊列期升，按照先進先出（FIFO，F(xiàn)irst-In-First-Out）的原則對元素進行排序荆几，和其他隊列對比吓妆，多出了兩個方法，分別是：transfer(E e)方法和tryTransfer(E e, long timeout, TimeUnit unit)方法吨铸。
• PriorityBlockingQueue：支持線程優(yōu)先級排序的沒有容量限制的阻塞隊列行拢，默認是按自然順序排序，也就是從優(yōu)先級低到高排序诞吱，也可以實現(xiàn)compareTo()方法來指定元素的排序規(guī)則舟奠，但是不能保證同優(yōu)先級元素的順序。
• SynchronousQueue：不存儲元素的阻塞隊列房维，支持公平鎖和非公平鎖沼瘫，每一個插入操作都必須要等待另一個線程的移除操作，每一個移除操作都必須要等待另一個線程的插入操作咙俩，其中耿戚，Executors.newCachedThreadPool()使用了這個隊列。

任務申請

任務申請相關的邏輯在getTask()方法中阿趁，源碼如下所示：

// ThreadPoolExecutor.java
private Runnable getTask() {
    boolean timedOut = false;

    // 循環(huán)執(zhí)行
    for (;;) {
        // 獲取線程池的運行狀態(tài)和工作線程數(shù)量
        int c = ctl.get();

        if (runStateAtLeast(c, SHUTDOWN)
            && (runStateAtLeast(c, STOP) || workQueue.isEmpty())) {
            // 如果線程池的運行狀態(tài)至少是SHUTDOWN狀態(tài)膜蛔，并且至少是STOP狀態(tài)，或者阻塞隊列為空脖阵，就執(zhí)行以下邏輯
            // 調用decrementWorkerCount()方法皂股，減少成員變量ctl的workerCount的值
            decrementWorkerCount();
            // 返回null
            return null;
        }

        // 獲取工作線程數(shù)量
        int wc = workerCountOf(c);

        // 獲取線程是否是回收狀態(tài)
        boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;

        if ((wc > maximumPoolSize || (timed && timedOut))
            && (wc > 1 || workQueue.isEmpty())) {
            if (compareAndDecrementWorkerCount(c))
                // 如果線程數(shù)量大于maximumPoolSize的值，也就是線程數(shù)量過多命黔，就返回null
                return null;
            continue;
        }

        try {
            // 如果線程是可回收的呜呐，就調用poll(long timeout, TimeUnit unit)方法，否則調用take()方法
            Runnable r = timed ?
                workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
                workQueue.take();
            if (r != null)
                return r;
            timedOut = true;
        } catch (InterruptedException retry) {
            timedOut = false;
        }
    }
}

執(zhí)行過程如下所示：

1. 獲取線程池的運行狀態(tài)和工作線程數(shù)量悍募。
2. 如果線程池已經(jīng)停止執(zhí)行蘑辑，就返回null，否則執(zhí)行步驟3坠宴。
3. 如果線程池數(shù)量過多以躯，就返回null，否則執(zhí)行執(zhí)行步驟4。
4. 如果該線程是可回收的忧设，就調用poll(long timeout, TimeUnit unit)方法，檢索并且刪除隊列的頭元素颠通，如果沒有足夠的空間址晕，就等待到指定的等待時間；如果該線程是不可回收的顿锰，就調用take()方法谨垃，檢索并且刪除隊列的頭元素，如果沒有足夠的空間硼控，就等待馒索。

任務拒絕

任務拒絕是線程池的保護機制跺涤，相關的邏輯在RejectedExecutionHandler中，源碼如下所示：

// RejectedExecutionHandler.java
public interface RejectedExecutionHandler {

    // 當線程池不能接受任務時，會調用這個方法
    void rejectedExecution(Runnable r, ThreadPoolExecutor executor);
}

看下接口RejectedExecutionHandler的實現(xiàn)類爽哎，可得知拒絕策略有以下幾種類型：

• ThreadPoolExecutor.AbortPolicy：線程池的默認拒絕策略，也就是ThreadPoolExecutor和ScheduledThreadPoolExecutor的默認拒絕策略爬早，丟棄任務氯夷，并且拋出RejectedExecutionException異常，建議使用這個策略撼短，因為可以方便通過異常發(fā)現(xiàn)再膳。
• ThreadPoolExecutor.CallerRunsPolicy：由提交任務的線程處理該任務，這種情況下曲横，需要等到所有任務執(zhí)行完畢喂柒，這種策略適合大量計算的任務類型。
• ThreadPoolExecutor.DiscardOldestPolicy：丟棄隊列最前面的任務禾嫉，然后重新提交被拒絕的任務灾杰，這種策略適合經(jīng)常需要丟棄舊的任務類型。
• ThreadPoolExecutor.DiscardPolicy：丟棄任務夭织，但是不拋出異常吭露，使用這種策略會導致我們無法發(fā)現(xiàn)異常。

工作線程管理

Worker類是線程池的工作線程的類尊惰，它是ThreadPoolExecutor類的一個被關鍵字final修飾的內部類讲竿，繼承了AbstractQueuedSynchronizer類，并且實現(xiàn)了Runnable接口弄屡，源碼如下所示：

// ThreadPoolExecutor.java
private final class Worker
    extends AbstractQueuedSynchronizer
    implements Runnable
{
    // 序列化版本號
    private static final long serialVersionUID = 6138294804551838833L;

    // 正在運行的工作線程题禀，如果創(chuàng)建失敗的，就為空
    final Thread thread;
    // 要運行的初始任務膀捷，可能為空
    Runnable firstTask;
    // 線程任務計數(shù)器
    volatile long completedTasks;

    // 從ThreadFactory中創(chuàng)建的第一個線程和任務
    Worker(Runnable firstTask) {
        // 在運行工作線程之前禁止中斷
        setState(-1);
        this.firstTask = firstTask;
        this.thread = getThreadFactory().newThread(this);
    }

    public void run() {
        // 調用runWorker(Worker w)方法
        runWorker(this);
    }

    // 以下是加鎖的方法迈嘹，值是0表示未解鎖狀態(tài)，值是1表示解鎖狀態(tài)

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

根據(jù)前面的源碼可得知，線程池使用HashSet存儲所有的工作線程秀仲，也就是存儲所有的Worker對象融痛，這樣就可以方便地通過添加或者刪除元素來控制線程池中的線程。

Worker類通過繼承AbstractQueuedSynchronizer類實現(xiàn)獨占鎖神僵，獨占鎖的意思是每次只有一個線程持有鎖雁刷，沒有使用ReentrantLock的原因是因為它是可重入鎖，線程池不能允許工作線程能夠多次獲取鎖保礼，所以使用AbstractQueuedSynchronizer沛励。

AbstractQueuedSynchronizer是依賴先進先出（FIFO，F(xiàn)irst-In-First-Out）的隊列的阻塞鎖和相關同步器（信號量炮障、事件等）實現(xiàn)的目派，里面維護著一個int的state。

添加工作線程

看下addWorker(Runnable firstTask, boolean core)方法胁赢，源碼如下所示：

// ThreadPoolExecutor.java
private boolean addWorker(Runnable firstTask, boolean core) {
    retry:
    for (int c = ctl.get();;) {
        // 獲取線程池的運行狀態(tài)和工作線程數(shù)量
        if (runStateAtLeast(c, SHUTDOWN)
            && (runStateAtLeast(c, STOP)
                || firstTask != null
                || workQueue.isEmpty()))
            // 如果線程池已經(jīng)停止企蹭，就添加工作線程失敗
            return false;

        // 循環(huán)執(zhí)行
        for (;;) {
            if (workerCountOf(c)
                >= ((core ? corePoolSize : maximumPoolSize) & COUNT_MASK))
                // 獲取工作線程數(shù)量，如果工作線程數(shù)量大于等于核心池大小或者最大池大小徘键，就添加工作線程失敗
                return false;
            // 增加workerCount（原子操作）
            if (compareAndIncrementWorkerCount(c))
                break retry;
            // 如果增加失敗练对，就再次獲取ctl
            c = ctl.get();
            if (runStateAtLeast(c, SHUTDOWN))
                // 如果中途有其他線程修改線程池的運行狀態(tài)，使其變成SHUTDOWN狀態(tài)吹害，就跳到retry標簽處螟凭，回到最外層的循環(huán)
                continue retry;
        }
    }

    // Worker對象對應的線程是否已經(jīng)啟動
    boolean workerStarted = false;
    // Worker對象是否添加到HashSet成功
    boolean workerAdded = false;
    Worker w = null;
    try {
        // 使用firstTask創(chuàng)建Worker對象
        w = new Worker(firstTask);
        // 根據(jù)Worker對象創(chuàng)建一個線程
        final Thread t = w.thread;
        if (t != null) {
            // 如果線程不為空，就創(chuàng)建ReentrantLock對象
            final ReentrantLock mainLock = this.mainLock;
            // 對mainLock加鎖
            mainLock.lock();
            try {
                // 保持鎖定狀態(tài)時再次檢查它呀，在ThreadFactory失敗或者在獲得鎖之前關閉退出
                int c = ctl.get();

                if (isRunning(c) ||
                    (runStateLessThan(c, STOP) && firstTask == null)) {
                    // 如果線程池處于小于STOP狀態(tài)螺男，也就是RUNNING狀態(tài)，就執(zhí)行以下邏輯
                    if (t.getState() != Thread.State.NEW)
                        // 如果線程不是創(chuàng)建狀態(tài)纵穿，就拋出IllegalThreadStateException異常
                        throw new IllegalThreadStateException();
                    // 將Worker對象添加到HashSet中
                    workers.add(w);
                    // Worker對象成功添加到HashSet
                    workerAdded = true;
                    int s = workers.size();
                    if (s > largestPoolSize)
                        // 如果線程數(shù)量大于最大池大小下隧，就將該值賦值給最大池大小
                        largestPoolSize = s;
                }
            } finally {
                // 對mainLock解鎖
                mainLock.unlock();
            }
            if (workerAdded) {
                // 如果Worker對象成功添加到HashSet中，就啟動線程
                t.start();
                workerStarted = true;
            }
        }
    } finally {
        if (! workerStarted)
            // 如果線程沒有啟動谓媒，就調用addWorkerFailed(Worker w)方法淆院，執(zhí)行回滾工作線程的創(chuàng)建，也就是做一些清理工作
            addWorkerFailed(w);
    }
    // 返回線程是否啟動成功
    return workerStarted;
}

執(zhí)行流程如下所示：

1. 檢查線程池是否已經(jīng)停止句惯，如果是土辩，就添加線程失敗，否則執(zhí)行步驟2抢野。
2. 檢查線程池是否正在停止拷淘，如果是，就執(zhí)行步驟3指孤，否則添加線程失敗启涯。
3. 檢查線程是否用于執(zhí)行剩余任務贬堵，如果是，就執(zhí)行步驟4结洼，否則添加線程失敗黎做。
4. 獲取工作線程數(shù)量，檢查線程池的運行狀態(tài)是否發(fā)生改變补君，如果有改變引几，執(zhí)行步驟1，否則執(zhí)行步驟5挽铁。
5. 檢查工作線程數(shù)量是否大于核心池大小或者最大池大小（取決于布爾型形式參數(shù)core敞掘，core是true叽掘，就使用核心池大小玖雁；core是false更扁，就使用最大池大小）赫冬，如果是浓镜，就添加線程失敗，否則執(zhí)行步驟6劲厌。
6. 把Worker對象存儲到HashSet中膛薛，如果成功添加，就啟動線程补鼻，否則執(zhí)行步驟4哄啄。

執(zhí)行工作線程

// ThreadPoolExecutor.java
final void runWorker(Worker w) {
    Thread wt = Thread.currentThread();
    // 獲取第一個任務
    Runnable task = w.firstTask;
    w.firstTask = null;
    w.unlock();
    boolean completedAbruptly = true;
    try {
        // 調用getTask獲取任務
        while (task != null || (task = getTask()) != null) {
            // 對Worker對象加鎖
            w.lock();
            if ((runStateAtLeast(ctl.get(), STOP) ||
                 (Thread.interrupted() &&
                  runStateAtLeast(ctl.get(), STOP))) &&
                !wt.isInterrupted())
                // 如果線程大于等于STOP狀態(tài)，并且線程還不是中斷狀態(tài)风范，就中斷線程
                wt.interrupt();
            try {
                // 調用beforeExecute(Thread t, Runnable r)方法咨跌，這個方法可以給子類去實現(xiàn)
                beforeExecute(wt, task);
                try {
                    // 執(zhí)行任務
                    task.run();
                    // 調用afterExecute(Runnable r, Throwable t)方法寇漫，這個方法是可以給子類去實現(xiàn)
                    afterExecute(task, null);
                } catch (Throwable ex) {
                    // 如果有異常，就調用afterExecute(Runnable r, Throwable t)方法猪腕，這個方法是可以給子類去實現(xiàn)
                    afterExecute(task, ex);
                    throw ex;
                }
            } finally {
                // task設為null，準備下一個任務
                task = null;
                // 完成任務數(shù)量的值自增
                w.completedTasks++;
                // 對Worker對象解鎖
                w.unlock();
            }
        }
        completedAbruptly = false;
    } finally {
        // 調用processWorkerExit(Worker w, boolean completedAbruptly)方法陋葡，回收工作線程
        processWorkerExit(w, completedAbruptly);
    }
}

執(zhí)行流程如下所示：

• 如果firstTask不為空，執(zhí)行firstTask，調用getTask()方法獲取任務執(zhí)行角塑。
• 如果firstTask為空，調用getTask()方法獲取任務執(zhí)行侥猩。

回收工作線程

// ThreadPoolExecutor.java
private void processWorkerExit(Worker w, boolean completedAbruptly) {
    if (completedAbruptly)
        // 如果completedAbruptly是true的話，證明workerCount的值還沒有被減少
        decrementWorkerCount();

    final ReentrantLock mainLock = this.mainLock;
    // 對mainLock加鎖
    mainLock.lock();
    try {
        completedTaskCount += w.completedTasks;
        // 移除HashSet中的對應的Worker對象
        workers.remove(w);
    } finally {
        // 對mainLock解鎖
        mainLock.unlock();
    }

    // 調用tryTerminate()方法，這個方法會調用terminated()方法，轉換成TERMINATED狀態(tài)
    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);
    }
}

執(zhí)行流程如下所示：

1. 檢查任務執(zhí)行情況溢陪，例如：檢查workCount的值是否被減少。
2. 移除HashSet中對應的Worker對象宝当。
3. 線程池的運行狀態(tài)變?yōu)門ERMINATED狀態(tài)订晌。

線程池的種類

在Executors類中封裝了五種線程池：

newFixedThreadPool

源碼如下所示：

// Executors.java
public static ExecutorService newFixedThreadPool(int nThreads) {
    return new ThreadPoolExecutor(nThreads, nThreads,
                                  0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<Runnable>());
}

public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory) {
    return new ThreadPoolExecutor(nThreads, nThreads,
                                  0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<Runnable>(),
                                  threadFactory);
}

該線程池線程數(shù)量固定虏辫，核心池大小（coolPoolSize）和最大池大行獠Α（maximumPoolSize）都一樣砌庄，并且keepAliveTime是0L，使用的阻塞隊列是LinkedBlockingQueue奕枢，它使用鏈表實現(xiàn)的有容量限制的阻塞隊列娄昆，按照先進先出（FIFO，F(xiàn)irst-In-First-Out）的原則對元素進行排序缝彬，默認長度是Integer.MAX_VALUE萌焰，所以默認創(chuàng)建該隊列可能有容量危險，該隊列通常比基于數(shù)組實現(xiàn)的隊列具有更高的吞吐量谷浅，但是在并發(fā)環(huán)境下扒俯，性能會比較差奶卓。

適用于在已知并發(fā)壓力下，執(zhí)行耗時長的任務的場景陵珍。

newWorkStealingPool

源碼如下所示：

// Executors.java
public static ExecutorService newWorkStealingPool(int parallelism) {
    return new ForkJoinPool
        (parallelism,
         ForkJoinPool.defaultForkJoinWorkerThreadFactory,
         null, true);
}

public static ExecutorService newWorkStealingPool() {
    return new ForkJoinPool
        (Runtime.getRuntime().availableProcessors(),
         ForkJoinPool.defaultForkJoinWorkerThreadFactory,
         null, true);
}

該線程池可以擁有多個隊列寝杖，以便減少連接數(shù)，默認線程數(shù)量是當前計算機可用的CPU數(shù)量互纯。

適用于耗時長瑟幕、需要并發(fā)執(zhí)行任務的場景。

newSingleThreadExecutor

源碼如下所示：

// Executors.java
public static ExecutorService newSingleThreadExecutor() {
    return new FinalizableDelegatedExecutorService
        (new ThreadPoolExecutor(1, 1,
                                0L, TimeUnit.MILLISECONDS,
                                new LinkedBlockingQueue<Runnable>()));
}

public static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory) {
    return new FinalizableDelegatedExecutorService
        (new ThreadPoolExecutor(1, 1,
                                0L, TimeUnit.MILLISECONDS,
                                new LinkedBlockingQueue<Runnable>(),
                                threadFactory));
}

該線程池線程數(shù)量只有一個留潦，核心池大兄豁铩（coolPoolSize）和最大池大小（maximumPoolSize）都1兔院，并且keepAliveTime是0L殖卑，使用的阻塞隊列是LinkedBlockingQueue，它使用鏈表實現(xiàn)的有容量限制的阻塞隊列坊萝，按照先進先出（FIFO孵稽，F(xiàn)irst-In-First-Out）的原則對元素進行排序，默認長度是Integer.MAX_VALUE十偶，所以默認創(chuàng)建該隊列可能有容量危險菩鲜，該隊列通常比基于數(shù)組實現(xiàn)的隊列具有更高的吞吐量，但是在并發(fā)環(huán)境下惦积，性能會比較差接校。

適用于需要保證任務執(zhí)行順序的場景。

newCachedThreadPool

源碼如下所示：

// Executors.java
public static ExecutorService newCachedThreadPool() {
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                  60L, TimeUnit.SECONDS,
                                  new SynchronousQueue<Runnable>());
}

public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory) {
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                  60L, TimeUnit.SECONDS,
                                  new SynchronousQueue<Runnable>(),
                                  threadFactory);
}

該線程池可以緩存線程狮崩，它會根據(jù)需要創(chuàng)建新線程蛛勉，但是會在可用的時候重用之前創(chuàng)建的線程，核心池大心啦瘛（coolPoolSize）是0诽凌，最大池大小（maximumPoolSize）是Integer.MAX_VALUE爱只，并且keepAliveTime是60L皿淋，使用的阻塞隊列是SynchronousQueue，它不存儲元素的阻塞隊列恬试，支持公平鎖和非公平鎖窝趣，每一個插入操作都必須要等待另一個線程的移除操作，每一個移除操作都必須要等待另一個線程的插入操作训柴。

適用于執(zhí)行耗時比較短的任務的場景哑舒。

newScheduledThreadPool

源碼如下所示：

// Executors.java
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
    return new ScheduledThreadPoolExecutor(corePoolSize);
}

public static ScheduledExecutorService newScheduledThreadPool(
        int corePoolSize, ThreadFactory threadFactory) {
    return new ScheduledThreadPoolExecutor(corePoolSize, threadFactory);
}

該線程池可以安排任務在給定的延遲后運行或者定期運行，使用的阻塞隊列是DelayedWorkQueue幻馁，它是一個支持延遲的阻塞隊列洗鸵。

適用于執(zhí)行周期性任務的場景越锈。

我的GitHub：TanJiaJunBeyond

Android通用框架：Android通用框架

我的掘金：譚嘉俊

我的簡書：譚嘉俊

我的CSDN：譚嘉俊