Android日記之線程池

前言

在編程中經常會使用線程來異步處理任務，但是每個線程的創建和銷毀都需要一定的開銷。如果每次執行一個任務都需要一個新進程去執行，則這些線程的創建和銷毀將消耗大量的資源；并且線程都是“各自為政”的，很難對其進行控制，更何況有一堆的線程在執行。這時候就需要線程池來對線程進行管理。在Java 1.5中提供了Executor框架用于把任務的提交和執行解耦。任務的提交交給RUnnable或者Callable，而Executor框架用來處理任務。Executor框架中最核心的成員就是ThreadPoolExecutor，它是線程池的核心實現類。本篇文章就著重講解ThreadPoolExecutor。

ThreadPoolExecutor介紹

可以通過ThreadPoolExecutor開創建一個線程池，ThreadPoolExecutor類一共有四個構造方法。下面展示的都是擁有最多參數的的構造方法。

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.corePoolSize = corePoolSize;
    this.maximumPoolSize = maximumPoolSize;
    this.workQueue = workQueue;
    this.keepAliveTime = unit.toNanos(keepAliveTime);
    this.threadFactory = threadFactory;
    this.handler = handler;
}

  • corePoolSize：核心線程數。默認情況下線程池是空的，只有任務提交時才會創建線程。如果當前運行的線程數少于corePoolSize，則會創建新線程來處理任務；如果等于或者多于corePoolSize，則不會創建，如果調用線程池的prestartAllcoreThread()方法，線程池會提前創建并啟動所有核心線程來等待任務。

  • maximumPoolSize：線程池允許創建的最大線程數，如果任務隊列滿了并且線程數小于maximumPoolSize時，則線程池仍舊會創建新的線程來處理任務。

  • keepAliveTime：非核心線程閑置的超時時間，超過這個事件則回收，如果任務很多，并且每個任務的執行事件很短，則可以調用keepAliveTime來提高線程的利用率。另外，如果設置allowCoreThreadTimeOut屬性為true時，keepAliveTime也會應用到核心線程上。

  • TimeUnit：keepAliveTime參數的時間單位，可選的單位有天（DAYS）、小時（HOURS）、分鐘（MINUTES）、秒（SECONDS）、毫秒（MILLOSECONDS）等。

  • BlockingQueue<Runnable> ：任務隊列，如果當前線程數大于corePoolSize，則將任務添加到此任務隊列中。該任務隊列是BlockiingQueue類型，也就是阻塞隊列。

  • ThreadFactory：線程工廠。可以用線程工廠給每個創建出來的線程設置名字。一般情況下無須設置參數。

  • RejectedExecutionHandler ：飽和策略，這是當任務隊列中和線程池都滿了時所采取的對應策略，默認是ABordPolicy，表示無法處理新任務，并拋出RejetctedExecutionException異常。此外還有3種策略，它們分別如下：

（1）CallerRunsPolicy：用調用者所在的線程來處理任務，此策略提供簡單的反饋控制機制，能夠減緩新任務的提交速度。
（2）DiscardPolicy：不能執行的任務，并將該任務刪除。
（3）DiscardOldestPolicy：丟棄隊列最近的任務，并執行當前的任務。

線程池的處理流程和原理

圖1，線程池的處理流程

從上圖1中可以得知線程的處理流程主要分為3個步驟：

  • 提交任務后，線程池先判斷線程數是否達到核心線程數（corePoolSize）。如果未核心線程數，則創建核心線程處理任務；否則就執行下一步操作。
  • 接著線程池判斷任務隊列是否滿了。如果沒滿，則將任務添加到任務隊列中，否則，就執行下一步操作。
  • 接著因為任務隊列滿了，線程池就會判斷線程數是否達到了最大線程數，如果未達到，則創建非核心線程1處理任務；否則，就執行飽和策略，默認會拋出RejectedExecutionException異常。

雖然上面介紹了線程池的處理流程，但還不是很直觀。我們結合下面的圖2來更好的了解線程池的原理。

圖2，線程池執行

從圖2中可以看到，如果我們執行ThreadPoolExecutor的execute方法，會遇到各種情況：
（1）如果線程池中的線程數未達到核心線程數，則創建核心線程處理任務。
（2）如果線程數大于或者等于核心線程數，則將任務加入任務隊列，線程池中的空閑線程會不斷地從任務隊列中取出任務進行處理。
（3）如果任務隊列滿了，并且線程數沒有達到最大線程數，則創建非核心線程去處理任務。
（4）如果線程數超過了最大線程數，則執行飽和策略。

ThreadPoolExecutor的基本使用

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    tools:context=".MainActivity">
    
    <Button
        android:id="@+id/btn_start"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="啟動" />
    
</LinearLayout>

package com.ju.executordemo;

import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.util.Log;
import android.view.View;
import android.widget.Button;

import java.util.Random;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class MainActivity extends AppCompatActivity{


    private Button btnStart;
    private final int CORE_POOL_SIZE = 4;//核心線程數
    private final int MAX_POOL_SIZE = 5;//最大線程數
    private final long KEEP_ALIVE_TIME = 10;//空閑線程超時時間
    private ThreadPoolExecutor executorPool;
    private int songIndex = 0;


    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        initView();
        //創建線程池
        initExec();
    }

    private void initView() {
        btnStart = findViewById(R.id.btn_start);
        btnStart.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                begin();
            }
        });
    }


    public void begin() {
        songIndex++;
        try {
            executorPool.execute(new WorkerThread("歌曲" + songIndex));
        } catch (Exception e) {
            Log.e("threadtest", "AbortPolicy...已超出規定的線程數量，不能再增加了....");
        }

        // 所有任務已經執行完畢，我們在監聽一下相關數據
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(20 * 1000);
                } catch (Exception e) {

                }
                sout("monitor after");
            }
        }).start();

    }

    private void sout(String msg) {
        Log.i("threadtest", "monitor " + msg
                + " CorePoolSize:" + executorPool.getCorePoolSize()
                + " PoolSize:" + executorPool.getPoolSize()
                + " MaximumPoolSize:" + executorPool.getMaximumPoolSize()
                + " ActiveCount:" + executorPool.getActiveCount()
                + " TaskCount:" + executorPool.getTaskCount()
        );
    }



    private void initExec() {
        executorPool = new ThreadPoolExecutor(CORE_POOL_SIZE,MAX_POOL_SIZE,KEEP_ALIVE_TIME, TimeUnit.SECONDS,
                new LinkedBlockingDeque<Runnable>(), Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy());
    }

    class WorkerThread implements Runnable {

        private String threadName;

        public WorkerThread (String name){
            threadName = name;
        }


        @Override
        public void run() {
            boolean flag = true;
            try {
                while (flag){
                    String tn  = Thread.currentThread().getName();
                    //模擬耗時操作
                    Random random = new Random();
                    long time = (random.nextInt(5) + 1) * 1000;
                    Thread.sleep(time);
                    Log.e("threadtest","線程\"" + tn + "\"耗時了(" + time / 1000 + "秒)下載了第<" + threadName + ">");
                    //下載完畢跳出循環
                    flag = false;
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }

}

圖3，運行結果

上述代碼模擬一個下載音樂的例子來演示ThreadPoolExecutor的基本使用，啟動ThreadPoolExecutor的函數是execute()方法，然后他需要一個Runnable的參數來進行啟動。

ThreadPoolExecutor的其它種類

通過直接或者間接地配置ThreadPoolExecutor的參數可以創建不同類型的ThreadPoolExecutor，其中有 4 種線程池比較常用，它們分別是 FixedThreadPool、CachedThreadPool、SingleThreadExecutor和 ScheduledThreadPool。下面分別介紹這4種線程池。

  • FixedThreadPool

FixedThreadPool 是可重用固定線程數的線程池。在 Executors 類中提供了創建FixedThreadPool的方法， 如下所示：

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

FixedThreadPool的corePoolSize和maximumPoolSize都設置為創建FixedThreadPool指定的參數nThreads，也就意味著FixedThreadPool只有核心線程，并且數量是固定的，沒有非核心線程。keepAliveTime設置為0L 意味著多余的線程會被立即終止。因為不會產生多余的線程，所以keepAliveTime是無效的參數。另外，任 務隊列采用了無界的阻塞隊列LinkedBlockingQueue。FixedThreadPool的execute方法的執行示意圖如圖4所 示。

圖4，FixedThreadPool流程圖

當執行execute()方法時，如果當前運行的線程未達到corePoolSize（核心線程數）時 就創建核心線程來處理任務，如果達到了核心線程數則將任務添加到LinkedBlockingQueue中。 FixedThreadPool就是一個有固定數量核心線程的線程池，并且這些核心線程不會被回收。當線程數超過corePoolSize時，就將任務存儲在任務隊列中；當線程池有空閑線程時，則從任務隊列中去取任務執行

  • CachedThreadPool

CachedThreadPool是一個根據需要創建線程的線程池，創建CachedThreadPool的代碼如下所示：

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

CachedThreadPool的corePoolSize為0，maximumPoolSize設置為Integer.MAX_VALUE，這意味著 CachedThreadPool沒有核心線程，非核心線程是無界的。keepAliveTime設置為60L，則空閑線程等待新任務 的最長時間為 60s。在此用了阻塞隊列 SynchronousQueue，它是一個不存儲元素的阻塞隊列，每個插入操作 必須等待另一個線程的移除操作，同樣任何一個移除操作都等待另一個線程的插入操作。CachedThreadPool 的execute方法的執行示意圖如圖5所示。

圖5，CachedThreadPool流程圖

當執行execute()方法時，首先會執行SynchronousQueue的offer()方法來提交任務，并且查詢線程池中是否有空閑的線程執行SynchronousQueue的poll()方法來移除任務。如果有則配對成功，將任務交給這個空閑的線程處理；如果沒有則配對失敗，創建新的線程去處理任務。當線程池中的線程空閑時，它會執行 SynchronousQueue的poll()方法，等待SynchronousQueue中新提交的任務。如果超過 60s 沒有新任務提交到 SynchronousQueue，則這個空閑線程將終止。因為maximumPoolSize 是無界的，所以如果提交的任務大于線 程池中線程處理任務的速度就會不斷地創建新線程。另外，每次提交任務都會立即有線程去處理。所以，CachedThreadPool比較適于大量的需要立即處理并且耗時較少的任務。

  • SingleThreadExecutor

SingleThreadExecutor是使用單個工作線程的線程池，其創建源碼如下所示：

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

corePoolSize和maximumPoolSize都為1，意味著SingleThreadExecutor只有一個核心線程，其他的參數都 和FixedThreadPool一樣，這里就不贅述了。SingleThreadExecutor的execute()方法的執行示意圖如圖5所示。

圖5，SingleThreadExecutor流程圖

當執行execute()方法時，如果當前運行的線程數未達到核心線程數，也就是當前沒有運行的線程，則創建一個新線程來處理任務。如果當前有運行的線程，則將任務添加到阻塞隊列LinkedBlockingQueue中。因此，SingleThreadExecutor能確保所有的任務在一個線程中按照順序逐一執行。

  • ScheduledThreadPool

ScheduledThreadPool是一個能實現定時和周期性任務的線程池，它的創建源碼如下所示：

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

這里創建了ScheduledThreadPoolExecutor，ScheduledThreadPoolExecutor繼承自ThreadPoolExecutor，它主要用于給定延時之后的運行任務或者定期處理任務。ScheduledThreadPoolExecutor 的構造方法如下所示：

public ScheduledThreadPoolExecutor(int corePoolSize) {
    super(corePoolSize, Integer.MAX_VALUE,
          DEFAULT_KEEPALIVE_MILLIS, MILLISECONDS,
          new DelayedWorkQueue());
}

從上面的代碼可以看出，ScheduledThreadPoolExecutor 的構造方法最終調用的是ThreadPoolExecutor的 構造方法。corePoolSize是傳進來的固定數值，maximumPoolSize的值是Integer.MAX_VALUE。因為采用的 DelayedWorkQueue是無界的，所以maximumPoolSize這個參數是無效的。ScheduledThreadPoolExecutor的 execute方法的執行示意圖如圖6所示。

圖6，ScheduledThreadPoolExecutor流程圖

當執行ScheduledThreadPoolExecutor的scheduleAtFixedRate()或者scheduleWithFixedDelay()方法時，會向DelayedWorkQueue添加一個 實現RunnableScheduledFuture接口的ScheduledFutureTask（任務的包裝類），并會檢查運行的線程是否達到corePoolSize。如果沒有則新建線程并啟動它，但并不是立即去執行任務，而是去DelayedWorkQueue中取ScheduledFutureTask，然后去執行任務。如果運行的線程達到了corePoolSize時，則將任務添加到DelayedWorkQueue中。DelayedWorkQueue會將任務進行排序，先要執行的任務放在隊列的前面。其跟此前介紹的線程池不同的是，當執行完任務后，會將ScheduledFutureTask中time變量改為下次要執行的時間并放回到DelayedWorkQueue中。

參考

最后編輯于 ：
?著作權歸作者所有,轉載或內容合作請聯系作者
平臺聲明：文章內容（如有圖片或視頻亦包括在內）由作者上傳并發布，文章內容僅代表作者本人觀點，簡書系信息發布平臺，僅提供信息存儲服務。

推薦閱讀更多精彩內容