楔子

蘇格拉底曾說過：“學會了多線程，你就學會了壓榨CPU，就好像資本家對無產階級做的那事一樣。”

多線程是開發人員必不可少的技術點，也是初學者不太容易掌握好的一個難點。要想設計出優秀的程序，那必然需要合理的線程調度。今天就給大家細說下Android中與多線程相關的知識點，揭開多線程神秘的面紗。

本篇文章僅介紹多線程的各種實現方式，不過多涉及深入的基礎原理探究，達到“所見即所學，所學即可用”的效果。關於各種多線程原理的深入探究，有機會放在後面的專欄逐一介紹。

一、多線程是什麼？我為什麼要用多線程？

1.1 線程和進程的概念

按照操作系統中的描述，線程是CPU調度的最小單元，同時線程是一種有限的系統資源。而進程一般指一個執行單元，在PC和移動設備上指一個程序或者一個應用。一個進程可以包含多個線程。

簡單點理解，一個Android APP就是一個進程，一個APP裡面有多個線程，我們多線程編程的意義就是實現“一個APP多個線程”。

有槓精可能會問，那我可不可以一個APP多個進程？又可不可以一個進程只有一個線程？

我告訴你，可以，都可以。

單線程的APP只包括Android的UI線程也是能運行的；一個APP多個進程也是可以達到的，實現方式涉及到Android的IPC機制，這裡不細說。

1.2 為什麼要使用多線程？

這裡槓精可能會說，那你單線程也能跑，我為啥還要整多線程？

我告訴你，首先這句話從Android開發的角度來講，近似於一個假命題。因為谷歌爸爸現在強制規定了不能在UI線程進行耗時操作，必須放到子線程裡面去，除非你的程序不涉及耗時操作。究其原因，是因為在UI線程進行耗時操作的話，給用戶的使用體驗就是界面“卡頓”。同時，如果UI線程被阻塞超過一定時間會觸發ANR(Application Not Responding)錯誤。

從底層的角度來講，多線程可以使得整個環境能夠異步執行，這有助於防止浪費CPU時鐘週期從而提高效率。換言之，多線程能更充分的利用CPU資源，從而提高程序的運行效率。

二、那我怎麼進行多線程編程？

2.1 Thread類和Runnable接口

要想定義一個線程只需要新建一個類繼承自Thread，然後重寫父類的run方法即可

<code>  class MyThread extends Thread {
      @Override
      public void run() {
          doSomething();
      }
  }

  //在需要的時候啟動線程
  new MyThread().start();
/<code>

優化一下？

我們可以沒必要繼承整個Thread類，只實現Runnable接口就好了

<code>  class MyThread implements Runnable {
      @Override
      public void run() {
          doSomething()
      }
  }

  //啟動線程
  MyThread myThread = new MyThread();
  new Thread(myThread).start();
/<code>

那我不想專門再寫一個線程類怎麼辦？可以使用匿名類

<code>  new Thread(new Runnable() {
      @Override
      public void run() { 

          doSomething();
      }
  }).start();
/<code>

2.2 線程池

2.2.1 線程池的意義

既然我都會用Runnable接口來創建線程了，還要線程池幹啥？其實不然，隨意創建線程的操作在實際開發中是極為不推薦的。為啥？因為線程也是一種資源，反覆的創建和銷燬線程會帶來一定性能上的額外開銷。與其相比，線程池主要有以下幾個優點：

• 重用線程池中的線程，避免因為線程的創建和銷燬所帶來的性能開銷
• 能有效控制線程池的最大併發數，避免大量的線程之間因相互搶佔系統資源而導致的阻塞現象
• 能夠對線程進行簡單的管理，並提供定時執行以及指定間隔循環執行等功能

2.2.2 線程池的結構和原理

一個完整的線程池應該有這麼幾個組成部分

• 核心線程
• 任務隊列
• 非核心線程

當我們通過線程池執行異步任務的時候，其實是依次進行了下面的流程

1. 檢查核心線程數是否到達最大值，否則創建新的核心線程執行任務，是則進行下一步
2. 檢查任務隊列是否已滿，否則將任務添加到任務隊列中，是則進行下一步
3. 檢查非核心線程數是否到達最大值，否則創建新的非核心線程執行任務，是則說明這個線程池已經飽和了，執行飽和策略。默認的飽和策略是拋出RejectedExecutionException異常

下面手搓一個線程池的實現

<code>  //CPU核心數
  private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
  //核心線程數
  private static final int CORE_POOL_SIZE = CPU_COUNT + 1;
  //最大線程數
  private static final int MAX_POOL_SIZE = CPU_COUNT * 2 + 1;
  //非核心線程閒置的超時時間
  private static final int KEEP_ALIVE_TIME = 1;
  //任務隊列
  private static final BlockingQueue<runnable> sPoolWorkQueue =
          new LinkedBlockingQueue<runnable>(128); 

  //線程池
  private ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(CORE_POOL_SIZE,
          MAX_POOL_SIZE, KEEP_ALIVE_TIME, TimeUnit.SECONDS, sPoolWorkQueue);

  private void fun(){
      Runnable runnable = new Runnable() {
          @Override
          public void run() {
              //子線程處理耗時操作
              doSomething();
          }
      };
      poolExecutor.execute(runnable);
  }
/<runnable>/<runnable>/<code>

這樣我們就實現了一個簡單的線程池，核心線程數為CPU數量+1，非核心線程數為CPU數量*2+1，非核心線程的閒置時間為1秒，任務隊列的大小為128。

線程池還有具體的好幾種分類和相應不同的實現方式，這裡不再細說。

2.3 Handler

有朋友可能會說，你講的這些都是Java多線程裡面的東西，能不能整點咱Android特有的？OK，現在進入專業時間。

Handler是Android提供的一種異步消息處理機制，要學會使用Handler我們首先來了解下消息處理四兄弟：

• Message
• Handler
• MessageQueue
• Looper

Handler可以幫助我們實現在不同的線程之間傳遞消息，這裡的Message就是消息本體，也就是我們想要傳遞的那個東西。

Handler在這裡扮演的角色是消息處理者，它的主要作用是發送和處理消息。MessageQueue是一個消息隊列，Handler發送過來的消息會放在這個隊列裡面，每個線程只會有一個MessageQueue對象。

Looper是線程中消息隊列的管家，它會無限循環運行，每發現MessageQueue中存在一條消息，它就會把消息取出然後發送給Handler。每一個線程也只能有一個Looper對象。

好了，基本原理已經瞭解，現在我們來反手搓一個Handler

<code>  private static final int FLAG = 1;

  private Handler mHandler = new Handler(){
      @Override
      public void handleMessage(@NonNull Message msg) {
          if (FLAG == msg.what){
              //這裡已經回到主線程了
              doSomething();
          }
      }
  };

  private void fun(){
      new Thread(new Runnable() {
          @Override
          public void run() {
              //子線程發送消息 

              Message message = new Message();
              message.what = FLAG;
              mHandler.sendMessage(message);
          }
      }).start();
  }
/<code>

2.4 AsyncTask

除了Handler以外，谷歌爸爸還給我們提供AsyncTask來進行線程的切換。AsyncTask是一種輕量級的異步任務，它可以在線程池中執行後臺任務，然後把執行的進度和最終結果傳遞給主線程。從實現原理上來講，AsyncTask是對Thread和Handle的再次封裝。

AsyncTask本身是一個抽象的泛型類，有四個親兒子：

• onPreExecute()
• doInBackground(Params...params)
• onProgressUpdate(Progress...values)
• onPostExecute(Result result)

最先執行的是方法是onPreExecute()方法，位於主線程中，一般用來做一些準備工作。

然後執行doInBackground()方法，位於線程池中，用來執行異步任務，params表示異步任務的輸入參數。這個方法需要返回結果給onPostExecute()方法。

onProgressUpdate()方法在主線程中執行，當後臺任務的執行進度發生變化時這個方法會被調用。

onPostExecute()方法在最後異步任務完成之後會被調用，位於主線程中，result參數是後臺任務的返回值，即doInBackground()的返回值。

OK，基本原理已經瞭解了，現在我們來手搓一個AsyncTask

<code>  class DownloadTask extends AsyncTask<void> {

      @Override
      protected void onPreExecute() {
          //這裡我們使用了一個顯示進度的Dialog，具體實現不表
          progressDialog.show();
      }

      @Override
      protected Boolean doInBackground(Void... voids) {
          try {
              while (true){
                  //調用我們的doDownload下載方法，具體實現不表
                  int downloadPercent = doDownload();
                  //使用publishProgress方法來更新執行的進度
                  publishProgress(downloadPercent);
                  if (downloadPercent >= 100)
                      break;
              }
          } catch (Exception e) {
              e.printStackTrace();
          }
          return true;
      }

      @Override
      protected void onProgressUpdate(Integer... values) {
          //更新下載進度
          progressDialog.setMessage("Download "+values[0]+"%");
      }

      @Override
      protected void onPostExecute(Boolean aBoolean) {
          //下載完成 

          progressDialog.dismiss();
      }
  }
/<void>/<code>

這裡我們創建了一個Download類繼承自AsyncTask，有三個泛型，void表示不需要給後臺任務傳入參數，Integer表示用整數類型來作為進度顯示的單位，Boolean表示用布爾類型來反饋後臺任務的執行結果。

要讓我們的這個AsyncTask跑起來也很簡單，只需要執行：

<code>  new DownloadTask().execute();
/<code>

2.5 IntentService

IntentService是一種特殊的Service，它繼承了Service並且是一個抽象類，我們可以創建它的子類來使用。IntentService也可以用於執行後臺的耗時任務，並且當任務執行完畢之後它會自動停止。

IntentService因為是服務的原因，所以和單純的線程相比它的優先級要高很多，從而更不容易被系統殺死。

IntentService的內部實現是封裝了HandlerThread和Handler，使用的話要遵循Service的使用方法，這裡先略過後面有機會在Service的專欄裡面再詳細介紹。

2.6 RxJava

有槓精可能會說，你講的這些方法，一個比一個長，一個比一個複雜，就不能整個簡單又粗暴的東西？

這個時候就需要祭出神兵利器RxJava了。

2.6.1 RxJava又是個啥？

其實網絡上RxJava的入門文章多如過江之鯽，這裡不打算過多的深入介紹。RxJava是一種響應式編程，大家不是很明白的話可以粗暴的理解為更優雅的多線程實現即可。

2.6.2 那怎麼操作RxJava？

先手搓一個RxJava的普通實現方式

<code>  private void fun(){
      Observable<integer> observable = Observable.create(new ObservableOnSubscribe<integer>() {
          @Override
          public void subscribe(ObservableEmitter<integer> emitter) throws Exception {
              emitter.onNext(1);
          }
      });

      observable.subscribeOn(Schedulers.io())     //表示在io線程執行訂閱
              .observeOn(AndroidSchedulers.mainThread())  //表示在主線程接收訂閱
              .subscribe(new Observer<integer>() {
                  @Override
                  public void onSubscribe(Disposable d) {
                      //接收訂閱之前調用
                  }

                  @Override
                  public void onNext(Integer integer) {
                      //接收訂閱成功調用
                      doSomething();
                  }

                  @Override
                  public void onError(Throwable e) {
                      //接收訂閱出錯調用 

                  }

                  @Override
                  public void onComplete() {
                      //接收訂閱完成調用
                  }
              });
  }
/<integer>/<integer>/<integer>/<integer>/<code>

emmmmm看起來好像還是挺複雜的啊，能不能再整簡單點？

OK，鏈式調用加lambda安排上

<code>  private void fun() {
      Observable.create(emitter -> emitter.onNext(1))
              .subscribeOn(Schedulers.io())
              .observeOn(AndroidSchedulers.mainThread())
              .subscribe(integer -> {
                  //接收訂閱成功
                  doSomething();
              }, throwable -> {});
  }
/<code>

嗯......有內味了。

這串代碼我們是發送了一個Integer類型的數據；

subscribeOn()指定了我們發送的線程是在後臺的io線程，就可以理解為一個子線程；

observeOn指定了我們接收的線程為主線程；

subscribe只接收成功的消息，相當於上面的OnNext()方法，本質上是我們在這裡創建了一個Comsumer對象來接收；

throwable在接收失敗的時候調用，相當於上面的onError()方法。

RxJava有多達幾十種的操作符，靈活運用能實現各種不同的異步任務，這裡就不再花大量的篇幅詳細介紹了，有興趣的朋友可以去查看ReactiveX中文文檔

2.7 RxKotlin

RxKotlin可以理解為RxJava在Kotlin上的一個變種，原理都是一樣的，只是操作語言變成了Kotlin，然後封裝了一下使得可以更優雅的調用，這裡給大家一個具體的實現案例，不再過多講解。

<code>  private fun test() {
      Observable.create { 1 }
              .subscribeOn(Schedulers.io())
              .observeOn(AndroidSchedulers.mainThread())
              .subscribeBy(
                      onNext = {},
                      onError = {}
              )
  }
/<code>

2.8 Kotlin協程

協程其實和上面所說的線程並不是一個概念，協程是什麼？根據官方文檔的描述，協程本質上是輕量級的線程。既然是輕量，那說明協程的資源消耗和性能等方面和線程比起來應該是有優勢的。那這樣看來我們以前使用多線程實現的異步功能，現在基本上都可以用協程來替代了。

協程是一個全新的東西，介於篇幅這裡就不展開講解了，後面會專門寫介紹協程的文章。

三、總結

今天總結了Android平臺上實現多線程的幾種方式，希望能給到需要的朋友一些幫助。

附上我的Android核心技術學習大綱，獲取相關內容開源私信我【PDF】

對於進階這條路而言，學習是會有回報的！

你把你的時間投資在學習上，就意味著你可以收穫技能，更有機會增加收入。

在這裡分享我的Android學習PDF大全來學習，這份Android學習PDF大全真的包含了方方面面了，內含Java基礎知識點、Android基礎、Android進階延伸、算法合集等等

我的這份學習合集，可以有效的幫助大家掌握知識點。

總之也是在這裡幫助大家學習提升進階，也節省大家在網上搜索資料的時間來學習，也可以分享給身邊好友一起學習

獲取方式：關注我看個人介紹，或直接 點擊我免費領取

閱讀更多 Android01 的文章

關鍵字: 多線程 設計 中央處理器