前言

android的執行緒池主要有四個：

newSingleThreadExecutor：單執行緒池，同時只有一個執行緒在跑。
newCachedThreadPool() ：回收型執行緒池，可以重複利用之前建立過的執行緒，執行執行緒最大數是Integer.MAX_VALUE。
newFixedThreadPool() ：固定大小的執行緒池，跟回收型執行緒池類似，只是可以限制同時執行的執行緒數量

哎？？？第四個是什麼來著，不知道你有沒有想起來，反正我是沒記住，結果面試的時候就栽了個跟頭。

正文

第四種執行緒池是ScheduledExecutorService，我平時沒有用過，他的最大優點除了執行緒池的特性以外，可以實現迴圈或延遲任務。

ScheduledExecutorService 和 Timer 的區別

Timer的內部只有一個執行緒，如果有多個任務的話就會順序執行，這樣我們的延遲時間和迴圈時間就會出現問題。

ScheduledExecutorService是執行緒池，所以就不會出現這個情況，在對延遲任務和迴圈任務要求嚴格的時候，就需要考慮使用ScheduledExecutorService了。

ScheduledExecutorService的用法主要有三個：

public class MainActivity extends AppCompatActivity {

    // 通過靜態方法建立ScheduledExecutorService的例項
 

    private ScheduledExecutorService mScheduledExecutorService = Executors.newScheduledThreadPool(4);

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        // 延時任務
        mScheduledExecutorService.schedule(threadFactory.newThread(new
 
 Runnable() {
            @Override
            public void run() {
                Log.e("lzp", "first task");
            }
        }), 1, TimeUnit.SECONDS);

        // 迴圈任務，按照上一次任務的發起時間計算下一次任務的開始時間
        mScheduledExecutorService.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                Log.e("lzp", "first:" + System.currentTimeMillis() / 1000);
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, 1, 1, TimeUnit.SECONDS);

        // 迴圈任務，以上一次任務的結束時間計算下一次任務的開始時間
        mScheduledExecutorService.scheduleWithFixedDelay(new Runnable() {
            @Override
            public void run() {
                Log.e("lzp", "scheduleWithFixedDelay:" + System.currentTimeMillis() / 1000);
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, 1, 1, TimeUnit.SECONDS);


    }
}

在程式碼中已經有註釋說明這三個方法的用法，重點是scheduleAtFixedRate和scheduleWithFixedDelay的區別，下面看具體看一下Log資訊：

首先是scheduleAtFixedRate：

從log上看，我們的迴圈任務嚴格按照每一秒發起一次，sleep（3000）對於任務的開啟是沒有影響的，也就是以上一個任務的開始時間 + 延遲時間 = 下一個任務的開始時間。

然後是scheduleWithFixedDelay：

從log上看，每一個任務的時間間隔是4秒，而不是我們設定的間隔1秒，任務要耗時3秒，兩個時間相加正好是4秒，那麼之前程式碼註釋的解釋就說的通了：以上一次任務的結束時間 + 延遲時間 = 下一次任務的開始時間。

擴充套件：ThreadFactory

因為線上程池的構造方法中，有ThreadFactory引數，所以就來簡單介紹一個ThreadFactory：

執行緒工廠，可以對傳入的Runnable進行加工操作，典型的工廠模式，需要實現newThread(@NonNull Runnable r) 方法返回加工後的執行緒。

看一下具體的程式碼：

private ThreadFactory threadFactory = new ThreadFactory() {
        @Override
        public Thread newThread(@NonNull final Runnable r) {
            return new Thread() {
                @Override
                public void run() {
                    r.run();
                    Log.e("lzp", "嘿嘿嘿");
                }
            };
        }
    };

例如上面的程式碼，我在引數Runnable物件的run方法後，增加了一句log列印。

然後修改MainActivity的呼叫：

mScheduledExecutorService.schedule(threadFactory.newThread(new Runnable() {
            @Override
            public void run() {
                Log.e("lzp", "first task");
            }
        }), 1, TimeUnit.SECONDS);

這裡面我傳入ThreadFactory加工過後的Runnable，我們推斷，最後應該會列印兩句：first task 和 嘿嘿嘿，執行一下看看是不是符合我們的期望：

果然結果沒有讓我們失望。

然後我有了一個想法，我要給執行緒池所有的執行緒都加工一下：

private ScheduledExecutorService mScheduledExecutorService = Executors.newScheduledThreadPool(4, new ThreadFactory() {
        @Override
        public Thread newThread(@NonNull Runnable r) {
           return new Thread(r){
                @Override
                public void run() {
                    Log.e("lzp", "newThread");
                    super.run();
                    Log.e("lzp", "newThread over");
                }
            };
        }
    });

我在Runnable引數的run方法前後增加了列印，於是我迫不及待的運行了app：

經過短暫的喜悅，我發現我的希望落空了，出現了兩個問題：

1、Log.e(“lzp”, “newThread over”) 這一句為什麼沒有執行？？？
2、為什麼ThreadFactory.newThread() 只執行了四次。

帶著疑問我開始檢視原始碼，經過仔細的思考，找到了問題的原因，這裡就簡單解釋一下：

1、執行緒池只會建立最大併發數（corePoolSize）的Worker物件。

2、Worker物件內部包含了Thread和Runnable資訊。

3、新增任務時：
如果Worker沒有到最大值，就建立Worker（通過ThreadFactory的newThread新建了Thread，所以Thread的數量等於Worker數量）；
如果已經是最大，就把任務放到佇列（Quene）中。

3、任務執行中：
如果Worker的Runnable不為空，執行Runnable，執行結束，Runnable設定為空；
如果Worker的Runnable為空，從佇列中取出任務執行。

4、Runnable執行結束，執行緒池內部直接退出了執行緒。

弄懂了內部的機制，剛才的問題就全都弄明白了，還發現android的設計者是不希望我們通過這種方法去影響Runnable的實現方法，但是可以去改變執行緒Thread物件的屬性，例如優先順序等等。

總結

這一篇我們先去弄懂了ScheduledExecutorService的特性和用法，然後瞭解了ThreadFactory的用法，最後兩者結合使用，分析並解決可能出現的問題。

由於執行緒池的原始碼還是很多的，這裡就不具體的解釋了，想具體瞭解的朋友可以自己去檢視原始碼或者網上檢視資料。

最後帶上原始碼連結，有問題或者建議可以留言。