【多線程】Android多線程學習筆記——線程池

前言

       轉載請聲明，轉自【https://www.cnblogs.com/andy-songwei/p/15313312.html】，謝謝！

      Java線程池采用了享元設計模式，在系統中維持一定數量的線程，用於處理異步或並發需求，在平時處理異步或並發任務時被廣泛使用。這里基於JDK1.8和Android28來整理一些關於線程池的知識點。本篇主要包含如下內容：

 

 

 

一、合理使用線程池的好處

    （1）降低資源消耗。 重用線程池，可以降低頻繁創建和銷毀線程所帶來的消耗。

    （2）提高響應速度。當任務到達時，任務可以不需要等到線程創建就能立即執行。假設一個服務器完成一項任務所需時間為：T1 創建線程時間，T2 在線程中執行任務的時間，T3 銷毀線程時間。如果：T1 + T3 遠大於 T2，則可以采用線程池，以提高程序的性能。線程池技術正是關注如何縮短或調整T1,T3時間的技術，從而提高程序性能的。它把T1，T3分別安排在程序的啟動和結束的時間段或者一些空閑的時間段，這樣在程序處理客戶請求時，不會有T1，T3的開銷了

    （3）提高線程的可管理性。線程是稀缺資源，如果無限制地創建，不僅會消耗系統資源，還可能導致大量的線程之間因互相搶占系統資源而導致阻塞。使用線程池可以進行統一分配、調優和監控。

 

二、Jdk提供的線程池框架

       Java中提供的線程池框架中，主要類的關系及結構如下圖所示：

•  Executor是一個接口，它是Executor框架的基礎，它將任務的提交與任務的執行分離開來。
• ExecutorService接口繼承了Executor，在其上做了一些shutdown()、submit()的擴展，可以說是真正的線程池接口；
• AbstractExecutorService抽象類實現了ExecutorService接口中的大部分方法；
• ThreadPoolExecutor是線程池的核心實現類，用來執行被提交的任務。
• ScheduledExecutorService接口繼承了ExecutorService接口，提供了帶"周期執行"功能ExecutorService；
• ScheduledThreadPoolExecutor是一個實現類，可以在給定的延遲后運行命令，或者定期執行命令。ScheduledThreadPoolExecutor比Timer更靈活，功能更強大。

 

三、線程池創建中各個參數的含義

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler)

•   corePoolSize 

      線程池的核心線程數，默認情況下，核心線程會在線程池中一直存活，即使它們處於閑置狀態。如果將ThreadPoolExecutor中的allowCoreThreadTimeOut屬性設置為true，那么閑置的核心線程在等待新任務到來時會有超時策略，這個時間間隔由keepAliveTime和unit所指定的時長決定，超過這個時長后核心線程就會被終止。

      在默認情況下，當提交一個任務時，線程池會創建一個新線程執行任務，直到當前線程數等於corePoolSize，而如果執行了ThreadPoolExecutor的prestartAllCoreThreads()方法，線程會提前創建並啟動所有核心線程；如果當前線程數為corePoolSize，繼續提交的任務會被保存到阻塞隊列中，等待被執行。

•   maximumPoolSize

    線程池所能容納的最大線程數。當阻塞隊列(即參數workQueue)滿了后，如果繼續提交任務，則創建新的線程執行任務，直到該線程池中所有活動的線程數達到maximumPoolSize。如果線程池中的活動線程數達到maximumPoolSize，后續還有新任務，就會執行線程池的拒絕策略，由另外一個參數RejectedExecutionHandler來確定。

• keepAliveTime

     非核心線程閑置時的超時時長，超過這個時長，非核心線程就會被回收。默認情況下，該參數只在線程數大於corePoolSize時才有用，而當ThreadPoolExecutor中的allowCoreThreadTimeOut屬性設置為true時，keepAliveTime同樣會作用於核心線程。

• unit

    用於指定keepAliveTime參數的時間單位，這是一個枚舉，常用的有TimeUnit.MILLISECONDS、TimeUnit.SECONDS、TimeUnit.MINUTES等。

• workQueue

       線程池的阻塞隊列，通過線程池的execute方法提交的Runnable對象會存儲在這個參數中。當線程池中的線程數超過它的corePoolSize的時候，線程會進入阻塞隊列進行阻塞等待。通過workQueue，線程池實現了阻塞功能。常用阻塞隊列有：

       1）ArrayBlockingQueue：一個由數組結構組成的有界阻塞隊列。此隊列按照先進先出（FIFO）的原則對元素進行排序。默認情況下不保證線程公平的訪問隊列，所謂公平訪問隊列是指阻塞的線程，可以按照阻塞的先后順序訪問隊列，即先阻塞線程先訪問隊列。非公平性是對先等待的線程是非公平的，當隊列可用時，阻塞的線程都可以爭奪訪問隊列的資格，有可能先阻塞的線程最后才訪問隊列。初始化時有參數可以設置

       2）LinkedBlockingQueue：一個由鏈表結構組成的有界阻塞隊列(常用)。此隊列的默認和最大長度為Integer.MAX_VALUE，它按照先進先出的原則對元素進行排序。

      3）PriorityBlockingQueue：一個支持優先級排序的無界阻塞隊列。

      4）DelayQueue：一個使用優先級隊列實現的無界阻塞隊列，支持延時獲取元素，隊列使用PriorityQueue來實現。隊列中的元素必須實現Delayed接口，在創建元素時可以指定多久才能從隊列中獲取當前元素。只有在延遲期滿時才能從隊列中提取元素。DelayQueue非常有用，可以將DelayQueue運用在緩存系統的設計：可以用DelayQueue保存緩存元素的有效期，使用一個線程循環查詢DelayQueue，一旦能從DelayQueue中獲取元素時，表示緩存有效期到了。

      5）SynchronousQueue：一個不存儲元素的阻塞隊列（常用）。每一個put操作必須等待一個take操作，否則不能繼續添加元素。SynchronousQueue可以看成是一個傳球手，負責把生產者線程處理的數據直接傳遞給消費者線程。隊列本身並不存儲任何元素，非常適合傳遞性場景。

      6）LinkedTransferQueue：一個由鏈表結構組成的無界阻塞隊列。

      7）LinkedBlockingDeque：一個由鏈表結構組成的雙向阻塞隊列。

以上的阻塞隊列都實現了BlockingQueue接口，也都是線程安全的。

       有界隊列就是長度有限，滿了以后生產者會阻塞，無界隊列就是里面能放無數的東西而不會因為隊列長度限制被阻塞，當然空間限制來源於系統資源的限制，如果處理不及時，導致隊列越來越大越來越大，超出一定的限制致使內存超限，操作系統或者JVM幫你解決煩惱，直接把你 OOM kill 省事了。無界也會阻塞，為何？因為阻塞不僅僅體現在生產者放入元素時會阻塞，消費者拿取元素時，如果沒有元素，同樣也會阻塞。

       一般來說，我們應該盡量使用有界隊列，因為使用無界隊列作為工作隊列會對線程池帶來如下影響：

      1）當線程池中的線程數達到corePoolSize后，新任務將在無界隊列中等待，因此線程池中的線程數不會超過corePoolSize。

      2）由於1，使用無界隊列時maximumPoolSize將是一個無效參數。

      3）由於1和2，使用無界隊列時keepAliveTime將是一個無效參數。

      4）更重要的，使用無界queue可能會耗盡系統資源，有界隊列則有助於防止資源耗盡，同時即使使用有界隊列，也要盡量控制隊列的大小在一個合適的范圍。

• threadFactory

    線程工廠，為線程池提供創建新線程的功能。ThreadFactory是一個接口： 

public interface ThreadFactory {
    Thread newThread(Runnable r);
}

       通過自定義的線程工廠可以給每個新建的線程設置一個具有識別度的線程名，當然還可以更加自由的對線程做更多的設置，比如設置所有的線程為守護線程。Executors靜態工廠里默認的threadFactory，線程的命名規則是“pool-數字-thread-數字”。

//java.util.concurrent.Executors.java
static class DefaultThreadFactory implements ThreadFactory {
    private static final AtomicInteger poolNumber = new AtomicInteger(1);
    private final ThreadGroup group;
    private final AtomicInteger threadNumber = new AtomicInteger(1);
    private final String namePrefix;
    DefaultThreadFactory() {
        SecurityManager s = System.getSecurityManager();
        group = (s != null) ? s.getThreadGroup() :
                              Thread.currentThread().getThreadGroup();
        namePrefix = "pool-" +
                      poolNumber.getAndIncrement() +
                     "-thread-";
    }
    public Thread newThread(Runnable r) {
        Thread t = new Thread(group, r,
                              namePrefix + threadNumber.getAndIncrement(),
                              0);
        if (t.isDaemon())
            t.setDaemon(false);
        if (t.getPriority() != Thread.NORM_PRIORITY)
            t.setPriority(Thread.NORM_PRIORITY);
        return t;
    }
}

• handler

      線程池的飽和策略，當阻塞隊列滿了，且沒有空閑的工作線程，如果繼續提交任務，必須采取一種策略處理該任務，線程池提供了4種策略：

（1）AbortPolicy：直接拋出RejectedException異常，默認策略；

（2）CallerRunsPolicy：用調用者所在的線程來執行任務；

（3）DiscardOldestPolicy：丟棄阻塞隊列中靠最前的任務，並執行當前任務；

（4）DiscardPolicy：直接丟棄任務；

當然也可以根據應用場景實現RejectedExecutionHandler接口，自定義飽和策略，如記錄日志或持久化存儲不能處理的任務。

 

四、線程池的工作機制

      1）如果當前運行的線程少於corePoolSize，則創建新線程來執行任務（注意，執行這一步驟需要獲取全局鎖）。

      2）如果運行的線程等於corePoolSize后仍然有任務提交，則將任務加入BlockingQueue。

      3）如果無法將任務加入BlockingQueue（隊列已滿），則創建新的線程來處理任務，其上限是當前活動線程數不超過maximumPoolSize。

      4）如果創建新線程時，當前運行的線程超出maximumPoolSize，任務將被拒絕，並調用RejectedExecutionHandler.rejectedExecution()方法。

 

五、提交任務

       execute()方法用於提交不需要返回值的任務，所以無法判斷任務是否被線程池執行成功。

       submit()方法用於提交需要返回值的任務。線程池會返回一個future類型的對象，通過這個future對象可以判斷任務是否執行成功，並且可以通過future的get()方法來獲取返回值，get()方法會阻塞當前線程直到任務完成，而使用get(long timeout，TimeUnit unit)方法則會阻塞當前線程一段時間后立即返回，這時候有可能任務沒有執行完。

 

六、關閉線程池

       可以通過調用線程池的shutdown或shutdownNow方法來關閉線程池。它們的原理是遍歷線程池中的工作線程，然后逐個調用線程的interrupt方法來中斷線程，所以無法響應中斷的任務可能永遠無法終止。但是它們存在一定的區別，shutdownNow首先將線程池的狀態設置成STOP，然后嘗試停止所有的正在執行或暫停任務的線程，並返回等待執行任務的列表，而shutdown只是將線程池的狀態設置成SHUTDOWN狀態，然后中斷所有沒有正在執行任務的線程。

       只要調用了這兩個關閉方法中的任意一個，isShutdown方法就會返回true。當所有的任務都已關閉后，才表示線程池關閉成功，這時調用isTerminaed方法會返回true。至於應該調用哪一種方法來關閉線程池，應該由提交到線程池的任務特性決定，通常調用shutdown方法來關閉線程池，如果任務不一定要執行完，則可以調用shutdownNow方法

 

七、 合理地配置線程池

要想合理地配置線程池，就必須首先分析任務特性，可以從以下幾個角度來分析。

    （1）任務的性質：CPU密集型任務、IO密集型任務和混合型任務。

    （2）任務的優先級：高、中和低。

    （3）任務的執行時間：長、中和短。

    （4）任務的依賴性：是否依賴其他系統資源，如數據庫連接。

       性質不同的任務可以用不同規模的線程池分開處理。

       CPU密集型任務應配置盡可能小的線程，如配置Ncpu+1（這為什么有個+1呢？這是因為在現代計算機中引入了虛擬內存技術，cpu讀取真實內存時可能該數據不在真實內存中，需要到虛擬內存中去取，這叫內存缺頁。而cpu讀取虛擬內存的速度遠小於讀取真實內存的速度，此時cpu只能等待。+1之后多了一個線程，當出現內存缺頁時，正在等待的cpu可以去執行這多出來的線程，從而提高cpu的使用率）個線程的線程池。由於IO密集型任務線程並不是一直在執行任務，則應配置盡可能多的線程，如2*Ncpu。

        混合型的任務，如果可以拆分，將其拆分成一個CPU密集型任務和一個IO密集型任務，只要這兩個任務執行的時間相差不是太大，那么分解后執行的吞吐量將高於串行執行的吞吐量。如果這兩個任務執行時間相差太大，則沒必要進行分解。可以通過Runtime.getRuntime().availableProcessors()方法獲得當前設備的CPU個數。

       優先級不同的任務可以使用優先級隊列PriorityBlockingQueue來處理。它可以讓優先級高的任務先執行。

       執行時間不同的任務可以交給不同規模的線程池來處理，或者可以使用優先級隊列，讓執行時間短的任務先執行。

       建議使用有界隊列。有界隊列能增加系統的穩定性和預警能力，可以根據需要設大一點兒，比如幾千。如果當時我們設置成無界隊列，那么線程池的隊列就會越來越多，有可能會撐滿內存，導致整個系統不可用，而不只是后台任務出現問題。

 

八、JDK中內置的4類線程池

       在JDK中的Executors類中提供了4類已經配置好的線程池：

 其源碼為：

//java.util.concurrent.Executors.java
public class Executors {
    ......
    //提供的默認的ThreadFactory
    public static ThreadFactory defaultThreadFactory() {
        return new DefaultThreadFactory();//在前文中有該類的代碼
    }
    ......
    public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
    }
    ......
    public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                  0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<Runnable>());
    }
    ......
    public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                0L, TimeUnit.MILLISECONDS,
                                new LinkedBlockingQueue<Runnable>()));
    }
    ....
}

public class ScheduledThreadPoolExecutor extends ThreadPoolExecutor implements ScheduledExecutorService {
    ....
    public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
    return new ScheduledThreadPoolExecutor(corePoolSize);
    }
    ....
    public ScheduledThreadPoolExecutor(int corePoolSize) {
    super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
          new DelayedWorkQueue());
    }
    ....
}

public class ThreadPoolExecutor extends AbstractExecutorService {
    ......
    public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
         Executors.defaultThreadFactory(), defaultHandler);
    }
    ......
}

1、CachedThreadPool線程池

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

       通過Executors的newCachedThreadPool方法來創建。它是一種線程數量不定的線程池它只有非核心線程，並且其最大線程數為IntegerMAX_VALUE。由於IntegerMAX VALUE是一個很大的數，實際上就相當於最大線程數可以任意大。當線程池中的線程都處於活動狀態時，線程池會創建新的線程來處理新任務，否則就會利用空閑的線程來處理新任務。線程池中的空閑線程都有超時機制，這個超時時長為60秒，超過60秒閑置線程就會被回收。和FixedThreadPool不同的是，CachedThreadPool的任務隊列其實相當於一個空集合。這將導致任何任務都會立即被執行，因為在這種場景下SynchronousQueue是無法插入任務的。SynchronousQueue是一個非常特殊的隊列，在很多情況下可以把它簡單理解為一個無法存儲元素的隊列，由於它在實際中較少使用，這里就不深入探討它了。從 CachedThreadPool的特性來看，這類線程池比較適合執行大量的耗時較少的任務。當整個線程池都處於閑置狀態時，線程池中的線程都會超時而被停止，這個時候CachedThreadPool之中實際上是沒有任何線程的，它幾乎是不占用任何系統資源的。

測試示例：

public static void testNewCachedThreadPool() throws InterruptedException {
    ExecutorService executorService = Executors.newCachedThreadPool();
    for (int i = 1; i < 10; i++) {
        Thread.sleep(10);
        final int finalI = i;
        executorService.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(("線程名稱：" + Thread.currentThread().getName() + "，執行" + finalI));
            }
        });
    }
}

輸出結果：

線程名稱：pool-1-thread-1，執行1
線程名稱：pool-1-thread-1，執行2 線程名稱：pool-1-thread-1，執行3 線程名稱：pool-1-thread-1，執行4 線程名稱：pool-1-thread-1，執行5 線程名稱：pool-1-thread-1，執行6 線程名稱：pool-1-thread-1，執行7 線程名稱：pool-1-thread-1，執行8 線程名稱：pool-1-thread-1，執行9

第一次提交任務后，創建了pool-1-thread-1線程，執行完任務后有60s的空閑期，執行每一個任務時間非常短，所以只創建了一個線程且所有任務均由其執行。

2、FixedThreadPool線程池

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

       通過Executors的newFixedThreadPool方法來創建。它是一種線程數量固定的線程池，當線程處於空閑狀態時，它們並不會被回收，除非線程池被關閉了。當所有的線程都處於活動狀態時，新任務都會處於等待狀態，直到有線程空閑出來。由於FixedThreadPool只有核心線程並且這些核心線程不會被回收，這意味着它能夠更加快速地響應外界的請求。 newFixedThreadPool方法的實現如上，可以發現FixedThreadPool中只有核心線程並且這些核心線程沒有超時機制，另外任務隊列也是沒有大小限制的。

測試示例：

public static void testNewFixedThreadPool() {
    ExecutorService executorService = Executors.newFixedThreadPool(3);
    for (int i = 0; i < 10; i++) {
        final int finalI = i;
        executorService.execute(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(("線程名稱：" + Thread.currentThread().getName() + "，執行" + finalI));
            }
        });
    }
}

輸出結果：

線程名稱：pool-1-thread-3，執行2
線程名稱：pool-1-thread-1，執行0 線程名稱：pool-1-thread-2，執行1 線程名稱：pool-1-thread-2，執行5 線程名稱：pool-1-thread-1，執行4 線程名稱：pool-1-thread-3，執行3 線程名稱：pool-1-thread-3，執行8 線程名稱：pool-1-thread-2，執行6 線程名稱：pool-1-thread-1，執行7 線程名稱：pool-1-thread-3，執行9

配置了3個核心線程，只有3個線程在執行任務。

3、SingleThreadExecutor線程池

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

       通過Executors的newSingleThreadExecutor方法來創建。這類線程池內部只有一個核心線程，它確保所有的任務都在同一個線程中按順序執行。SingleThreadExecutor的意義在於統一所有的外界任務到一個線程中這使得在這些任務之間不需要處理線程同步的問題。

測試示例：

public static void testNewSingleThreadExecutor() {
    ExecutorService executorService = Executors.newSingleThreadExecutor();
    for (int i = 1; i < 10; i++) {
        final int finalI = i;
        executorService.execute(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(("線程名稱：" + Thread.currentThread().getName() + "，執行" + finalI));
            }
        });
    }
}

輸出結果：

線程名稱：pool-1-thread-1，執行1
線程名稱：pool-1-thread-1，執行2 線程名稱：pool-1-thread-1，執行3 線程名稱：pool-1-thread-1，執行4 線程名稱：pool-1-thread-1，執行5 線程名稱：pool-1-thread-1，執行6 線程名稱：pool-1-thread-1，執行7 線程名稱：pool-1-thread-1，執行8 線程名稱：pool-1-thread-1，執行9

盡管每個任務都執行時間都超過了2s，但始終只有1個線程在執行。

4、ScheduledThreadPool線程池

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

//ScheduledThreadPoolExecutor是ThreadPoolExecutor的子類
public ScheduledThreadPoolExecutor(int corePoolSize) {
    super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
          new DelayedWorkQueue());
}

      通過Executors的newSingleThreadExecutor方法來創建。這類線程池內部只有一個核心線程，它確保所有的任務都在同一個線程中按順序執行。SingleThreadExecutor的意義在於統一所有的外界任務到一個線程中，這使得在這些任務之間不需要處理線程同步的問題。

測試示例：

private static void testNewScheduledThreadPool() {
    ScheduledExecutorService executorService = Executors.newScheduledThreadPool(5);
    executorService.schedule(new Runnable() {
        @Override
        public void run() {
            System.out.println("線程名稱：" + Thread.currentThread().getName() + "，執行:3秒后執行");
        }
    }, 3, TimeUnit.SECONDS);
    executorService.scheduleAtFixedRate(new Runnable() {
        @Override
        public void run() {
            System.out.println("線程名稱：" + Thread.currentThread().getName() + "，執行:延遲2秒后每3秒執行一次");
        }
    }, 2, 3, TimeUnit.SECONDS);
    for (int i = 0; i < 5; i++) {
        final int finalI = i;
        executorService.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println("線程名稱：" + Thread.currentThread().getName() + "，執行:普通任務-" + finalI);
            }
        });
    }
}

輸出結果：

線程名稱：pool-1-thread-1，執行:普通任務-0
線程名稱：pool-1-thread-2，執行:普通任務-1 線程名稱：pool-1-thread-3，執行:普通任務-2 線程名稱：pool-1-thread-4，執行:普通任務-3 線程名稱：pool-1-thread-5，執行:普通任務-4 線程名稱：pool-1-thread-2，執行:延遲2秒后每3秒執行一次 線程名稱：pool-1-thread-1，執行:3秒后執行 線程名稱：pool-1-thread-4，執行:延遲2秒后每3秒執行一次 線程名稱：pool-1-thread-4，執行:延遲2秒后每3秒執行一次 線程名稱：pool-1-thread-4，執行:延遲2秒后每3秒執行一次 線程名稱：pool-1-thread-4，執行:延遲2秒后每3秒執行一次 線程名稱：pool-1-thread-4，執行:延遲2秒后每3秒執行一次 線程名稱：pool-1-thread-4，執行:延遲2秒后每3秒執行一次

定時和延遲執行。

 

九、線程池在AsyncTask中的使用

       AsyncTask執行異步任務就是一個很典型的線程池使用范例，這里我們來看看其中是如何使用線程池的。

  1、線程池參數的配置

private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
// We want at least 2 threads and at most 4 threads in the core pool,
// preferring to have 1 less than the CPU count to avoid saturating
// the CPU with background work
private static final int CORE_POOL_SIZE = Math.max(2, Math.min(CPU_COUNT - 1, 4));
private static final int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1;
private static final int KEEP_ALIVE_SECONDS = 30;
private static final ThreadFactory sThreadFactory = new ThreadFactory() {
    private final AtomicInteger mCount = new AtomicInteger(1);
    public Thread newThread(Runnable r) {
        return new Thread(r, "AsyncTask #" + mCount.getAndIncrement());
    }
};
private static final BlockingQueue<Runnable> sPoolWorkQueue =
        new LinkedBlockingQueue<Runnable>(128);

public static final Executor THREAD_POOL_EXECUTOR;
static {
    ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
            CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE_SECONDS, TimeUnit.SECONDS,
            sPoolWorkQueue, sThreadFactory);
    threadPoolExecutor.allowCoreThreadTimeOut(true);
    THREAD_POOL_EXECUTOR = threadPoolExecutor;
}
......

  2、AsyncTask執行任務使用范例

一般使用AsyncTask執行任務的時候，使用方式如下：

new AsyncTask<Object, Object, Object>() {
    @Override
    protected Object doInBackground(Object[] objects) {
        return null;
    }
}.execute();

  3、AysncTask使用線程池執行任務源碼分析

private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;
public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
private static class SerialExecutor implements Executor {
    final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();
    Runnable mActive;
    public synchronized void execute(final Runnable r) {
        mTasks.offer(new Runnable() {
            public void run() {
                try {
                    r.run();
                } finally {
                    scheduleNext();
                }
            }
        });
        if (mActive == null) {
            scheduleNext();
        }
    }
    protected synchronized void scheduleNext() {
        if ((mActive = mTasks.poll()) != null) {
            THREAD_POOL_EXECUTOR.execute(mActive);
        }
    }
}

public final AsyncTask<Params, Progress, Result> execute(Params... params) {
    return executeOnExecutor(sDefaultExecutor, params);
}
public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec,Params... params) {
    ......
    exec.execute(mFuture);
    return this;
}

第22行就是線程池調用了執行任務的方法。

本文知識點主要來源於任玉剛的《Android開發藝術探索》和某學課堂視頻教程的教案，並借鑒了https://www.cnblogs.com/zincredible/p/10984459.html的舉例。