使用過AsyncTask、EventBus、Volley以及Retrofit，必須好好瞭解handler運行機制

来源:https://www.cnblogs.com/firebullio/archive/2018/08/24/9528337.html
-Advertisement-
Play Games

我們都知道在UI線程中不能進行耗時操作，例如數據讀寫、網路請求。Android 4.0開始，在主線程中進行網路請求甚至會拋出Android.os.NetworkOnMainThreadException。這個時候，我們就會開始依賴Handler。我們在子線程進行耗時操作後，將請求結果通過Handle ...


我們都知道在UI線程中不能進行耗時操作，例如數據讀寫、網路請求。Android 4.0開始，在主線程中進行網路請求甚至會拋出Android.os.NetworkOnMainThreadException。這個時候，我們就會開始依賴Handler。我們在子線程進行耗時操作後，將請求結果通過Handler的sendMessge**() 方法發送出去，在主線程中通過Handler的handleMessage 方法處理請求結果，進行UI的更新。

後來隨著AsyncTask、EventBus、Volley以及Retrofit 的出現，Handler的作用似乎被弱化，逐漸被大家遺忘。其實不然，AsyncTask其實是基於Handler進行了非常巧妙的封裝，Handler的使用依然是其核心。Volley同樣也是使用到了Handler。因此，我們有必要瞭解一下Handler的實現機制。

神奇的Handler

記得很久之前的一天，我在閱讀別人的代碼時，看到了這樣一段：

  1.   new Handler().postDelayed(new Runnable() {
  2.   @Override
  3.   public void run() {
  4.   Toast.makeText(mContext, "I'm new Handler !", Toast.LENGTH_SHORT).show();
  5.   }
  6.   }, 1000);

第一印象就是，這不是在子線程中進行UI操作嗎？這代碼有問題吧，於是乎立刻在自己電腦上寫了個demo試了一下，結果發現真的沒有問題。在一陣懵逼過後，我又寫出下麵的代碼，測試一下子線程中到底能不能進行UI操作。

  1.   new Thread(new Runnable() {
  2.   @Override
  3.   public void run() {
  4.    
  5.   try {
  6.   Thread.sleep(2000);
  7.   } catch (InterruptedException e) {
  8.   e.printStackTrace();
  9.   }
  10.    
  11.   Toast.makeText(mContext, "I'm new Thread !", Toast.LENGTH_SHORT).show();
  12.    
  13.   }
  14.   }).start();

結果很明顯，程式一啟動立刻就奔潰了。並拋出異常java.lang.RuntimeException: Can't create handler inside thread that has not called Looper.prepare()。
於是乎我又在try block 之前添加了Looper.prepare()這行代碼。再次運行程式雖然沒有奔潰，但也沒有任何反應，Toast也沒顯示。

那麼Handler到底是什麼呢？他怎麼就這麼神奇。

實現機制解析

首先，我們從整體上瞭解一下，在整個Handler機制中所有使用到的類，主要包括Message，MessageQueue,Looper以及Handler。

 

 

好了，為了方便後面的敘述，我們就首先瞭解一下這個類圖中使用到幾個類，及其關鍵方法。

Message

首先看一下Message這個類的定義（截取部分）

  1.   public final class Message implements Parcelable {
  2.    
  3.   public int what;
  4.   public int arg1;
  5.   public int arg2;
  6.   public Object obj;
  7.   /*package*/ Handler target;
  8.   /*package*/ Runnable callback;
  9.    
  10.   /**
  11.   * Return a new Message instance from the global pool. Allows us to
  12.   * avoid allocating new objects in many cases.
  13.   */
  14.   public static Message obtain() {
  15.   synchronized (sPoolSync) {
  16.   if (sPool != null) {
  17.   Message m = sPool;
  18.   sPool = m.next;
  19.   m.next = null;
  20.   m.flags = 0; // clear in-use flag
  21.   sPoolSize--;
  22.   return m;
  23.   }
  24.   }
  25.   return new Message();
  26.   }
  27.    
  28.   /** Constructor (but the preferred way to get a Message is to call {@link #obtain() Message.obtain()}).
  29.   */
  30.   public Message() {
  31.   }
  32.   }

看到這個類的前四個屬性，大家應該很熟悉，就是我們使用Handler時經常用到的那幾個屬性。用來在傳遞我們特定的信息。其次我們還可以總結出以下信息：

  • Message 實現了Parcelable 介面，也就是說實現了序列化，這就說明Message可以在不同進程之間傳遞。
  • 包含一個名為target的Handler 對象
  • 包含一個名為callback的Runnable 對象
  • 使用obtain 方法可以從消息池中獲取Message的實例，也是推薦大家使用的方法，而不是直接調用構造方法。

MessageQueue

MessageQueue顧名思義，就是上面所說的Message所組成的queue。

首先看一下構造方法：

  1.   MessageQueue(boolean quitAllowed) {
  2.   mQuitAllowed = quitAllowed;
  3.   mPtr = nativeInit();
  4.   }

接收一個參數，決定當前隊列是否允許被終止。同時調用 一個native方法，初始化了一個long類型的變數mPtr。

同時，在這個類當中，還定義了一個next 方法，用於返回一個Message 。

  1.   Message next() {
  2.   // Return here if the message loop has already quit and been disposed.
  3.   // This can happen if the application tries to restart a looper after quit
  4.   // which is not supported.
  5.   final long ptr = mPtr;
  6.   if (ptr == 0) {
  7.   return null;
  8.   }
  9.   ……
  10.   }

由於這個方法中有一些native調用，未能完全理解，只知道會返回一個Message對象。

這個next方法相當於是隊列出棧，有出棧必然有進棧，enqueueMessage 方法就是完成這個操作；這個我們後面再說。

Looper

上面說到了MessageQueue，那麼這個Queue又是由誰創建的呢？其實就是Looper。關於Looper有兩個關鍵方法：

prepare() 和 loop()

Looper-prepare()

  1.   public static void prepare() {
  2.   prepare(true);
  3.   }
  4.    
  5.   private static void prepare(boolean quitAllowed) {
  6.   if (sThreadLocal.get() != null) {
  7.   throw new RuntimeException("Only one Looper may be created per thread");
  8.   }
  9.   sThreadLocal.set(new Looper(quitAllowed));
  10.   }

可以看到，對於每一個線程只能有一個Looper。也就是說執行prepare方法時，必然執行最後一行代碼
sThreadLocal.set(new Looper(quitAllowed));

我們再看Looper(quitAllowed)方法：

  1.   private Looper(boolean quitAllowed) {
  2.   mQueue = new MessageQueue(quitAllowed);
  3.   mThread = Thread.currentThread();
  4.   }

這樣，MessageQueue 就被創建了。這裡也可以看到，預設情況下，一個MessageQueue的quiteAllow=true。

這裡使用到的sThreadLocal 是一個ThreadLocal對象。簡單來說，使用它可以用來解決多線程程式的併發問題。使用set方法，將此線程局部變數的當前線程副本中的值設置為指定值；使用get方法，返回此線程局部變數的當前線程副本中的值。

Looper-loop()

再看一下loop方法（截取主要邏輯）

  1.   public static void loop() {
  2.   final Looper me = myLooper();
  3.   if (me == null) {
  4.   throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
  5.   }
  6.   final MessageQueue queue = me.mQueue;
  7.   for (;;) {
  8.   Message msg = queue.next(); // might block
  9.   if (msg == null) {
  10.   // No message indicates that the message queue is quitting.
  11.   return;
  12.   }
  13.   msg.target.dispatchMessage(msg);
  14.   msg.recycleUnchecked();
  15.   }
  16.   }

首先看第一句代碼執行的方法：

  1.   /**
  2.   * Return the Looper object associated with the current thread. Returns
  3.   * null if the calling thread is not associated with a Looper.
  4.   */
  5.   public static @Nullable Looper myLooper() {
  6.   return sThreadLocal.get();
  7.   }

很明顯，這樣返回的Looper就是剛纔prepare時set進去的那個，因為都是在同一線程。再明確一下，一個線程對應一個Looper。

這樣就確保我們可以在不同的線程中創建各自的Handler，進行各自的通信而不會互相干擾

回到代碼，後面邏輯就很簡單了，在一個死迴圈中，通過隊列出棧的形式，不斷從MessageQueue 中取出新的Message，然後執行msg.target.dispatchMessage(msg) 方法，還記的前面Message類的定義嗎，這個target屬性其實就是一個Handler 對象，因此在這裡就會不斷去執行Handler 的dispatchMessage 方法。如果取出的Message對象為null，就會跳出死迴圈，一次Handler的工作整個就結束了。

Handler

上面說了這麼多終於輪到Handler，那麼就看看在Handler中到底發生了什麼。回到我們一開始的代碼。

  1.   new Handler().postDelayed(new Runnable() {
  2.   @Override
  3.   public void run() {
  4.   String currentName=Thread.currentThread().getName();
  5.   Toast.makeText(mContext, "I'm new Thread "+currentName, Toast.LENGTH_SHORT).show();
  6.   }
  7.   }, 4000);

這裡我們用Toast彈出了當前線程的name，結果發現這個線程的名字居然是main，這也是必然結果

讓我們一步一步看看，神奇的Handler到底是怎樣工作的。就從這個代碼開始解讀。首先看一下Handler的構造方法。

  1.   public Handler() {
  2.   this(null, false);
  3.   }
  4.    
  5.   ---------------
  6.    
  7.   public Handler(Callback callback, boolean async) {
  8.   if (FIND_POTENTIAL_LEAKS) {
  9.   final Class<? extends Handler> klass = getClass();
  10.   if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) &&
  11.   (klass.getModifiers() & Modifier.STATIC) == 0) {
  12.   Log.w(TAG, "The following Handler class should be static or leaks might occur: " +
  13.   klass.getCanonicalName());
  14.   }
  15.   }
  16.    
  17.   mLooper = Looper.myLooper();
  18.   if (mLooper == null) {
  19.   throw new RuntimeException(
  20.   "Can't create handler inside thread that has not called Looper.prepare()");
  21.   }
  22.   mQueue = mLooper.mQueue;
  23.   mCallback = callback;
  24.   mAsynchronous = async;
  25.   }

這裡做的事情很簡單，就是完成了一些初始化的工作，調用Looper.myLooper()賦值給當前mLooper，關聯MessageQueue；這裡由於代碼中調用的是不帶任何參數的構造函數，因此會創建一個mCallback=null且非非同步執行的Handler 。

接下看postDelayed 方法。

  1.   public final boolean postDelayed(Runnable r, long delayMillis)
  2.   {
  3.   return sendMessageDelayed(getPostMessage(r), delayMillis);
  4.   }
  5.    
  6.   private static Message getPostMessage(Runnable r) {
  7.   Message m = Message.obtain();
  8.   m.callback = r;
  9.   return m;
  10.   }

這裡通過getPostMessage(Runnable r) 方法，把我們在Activity里寫的Runnable 這個線程賦給了Message 的callback這個屬性。

平時大家使用Handler也發現了，他為我們提供了很多方法

 

 

因此，上面的postDelayed經過了各種輾轉反側，最終來到了這裡：

  1.   public boolean sendMessageAtTime(Message msg, long uptimeMillis) {
  2.   MessageQueue queue = mQueue;
  3.   if (queue == null) {
  4.   RuntimeException e = new RuntimeException(
  5.   this + " sendMessageAtTime() called with no mQueue");
  6.   Log.w("Looper", e.getMessage(), e);
  7.   return false;
  8.   }
  9.   return enqueueMessage(queue, msg, uptimeMillis);
  10.   }

經過之前的構造方法，mQueue顯然不為null，繼續往下看

  1.   private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
  2.   msg.target = this;
  3.   if (mAsynchronous) {
  4.   msg.setAsynchronous(true);
  5.   }
  6.   return queue.enqueueMessage(msg, uptimeMillis);
  7.   }

註意，註意，註意 這裡進行了一次賦值：

msg.target = this;

前面提到，這個target就是一個Handler對象，因此這裡Message就和當前Handler關聯起來了。enqueueMessage，哈哈，這就是我們之前在MessageQueue中提到的進棧操作的方法，我們看一下：

  1.   boolean enqueueMessage(Message msg, long when) {
  2.   if (msg.target == null) {
  3.   throw new IllegalArgumentException("Message must have a target.");
  4.   }
  5.   if (msg.isInUse()) {
  6.   throw new IllegalStateException(msg + " This message is already in use.");
  7.   }
  8.    
  9.   synchronized (this) {
  10.   if (mQuitting) {
  11.   IllegalStateException e = new IllegalStateException(
  12.   msg.target + " sending message to a Handler on a dead thread");
  13.   Log.w(TAG, e.getMessage(), e);
  14.   msg.recycle();
  15.   return false;
  16.   }
  17.    
  18.   msg.markInUse();
  19.   msg.when = when;
  20.   Message p = mMessages;
  21.   boolean needWake;
  22.   if (p == null || when == 0 || when < p.when) {
  23.   // New head, wake up the event queue if blocked.
  24.   msg.next = p;
  25.   mMessages = msg;
  26.   needWake = mBlocked;
  27.   } else {
  28.   // Inserted within the middle of the queue. Usually we don't have to wake
  29.   // up the event queue unless there is a barrier at the head of the queue
  30.   // and the message is the earliest asynchronous message in the queue.
  31.   needWake = mBlocked && p.target == null && msg.isAsynchronous();
  32.   Message prev;
  33.   for (;;) {
  34.   prev = p;
  35.   p = p.next;
  36.   if (p == null || when < p.when) {
  37.   break;
  38.   }
  39.   if (needWake && p.isAsynchronous()) {
  40.   needWake = false;
  41.   }
  42.   }
  43.   msg.next = p; // invariant: p == prev.next
  44.   prev.next = msg;
  45.   }
  46.    
  47.   // We can assume mPtr != 0 because mQuitting is false.
  48.   if (needWake) {
  49.   nativeWake(mPtr);
  50.   }
  51.   }
  52.   return true;
  53.   }

這個方法就是典型的隊列入隊操作，只不過會根據Message這個對象特有的一些屬性，以及當前的狀態是否inUse，是否已經被quit等進行一些額外的判斷。

這樣，我們就完成消息入隊的操作。還記得我們在Looper中說過，在loop方法中，會從MessageQueue中取出Message 並執行他的dispatchMessage 方法。

dispatchMessage

  1.   public void dispatchMessage(Message msg) {
  2.   if (msg.callback != null) {
  3.   handleCallback(msg);
  4.   } else {
  5.   if (mCallback != null) {
  6.   if (mCallback.handleMessage(msg)) {
  7.   return;
  8.   }
  9.   }
  10.   handleMessage(msg);
  11.   }
  12.   }

到這裡，就很明確了，在之前的postDelayed 方法中，已經通過getPostMessage，實現了 m.callback = r；這樣這裡就會執行第一個if語句：

  1.   private static void handleCallback(Message message) {
  2.   message.callback.run();
  3.   }

這樣，就會執行我們在Activity 的Runnable 中的run 方法了，也就是顯示Toast。

到了這裡，我們終於明白了，使用Handler 的postDelay 方法時，其Runnable中的run方法並不是在子線程中執行，而是把這個Runnable賦值給了一個Message對象的callback屬性，而這個Message會被傳遞到創建Handler所在的線程，也就是這裡的主線程，所以這個Toast的顯示依舊是在主線程中。這也和postDelay API 中所聲明的內容是一致的。

/**

  1.   * Causes the Runnable r to be added to the message queue, to be run
  2.   * after the specified amount of time elapses.
  3.   * The runnable will be run on the thread to which this handler
  4.   * is attached.
  5.   */

到這裡，一開始所說的第一個代碼塊所執行的邏輯已經理清楚了，但是還是有一點疑問，我們並沒有在Handler的構造方法中看到Looper 的prepare()方法和loop() 方法被執行，那麼他們到底是在哪裡執行的呢？這個問題我也是疑惑了很久，最終才明白是在
ActivityThread的main方法中執行。簡單來說，ActivityThread是Java層面一個Android程式真正的入口。關於ActivityThread更多的內容可以看看這篇文章。

ActivityThread-main方法（截取主要部分）

  1.   public static void main(String[] args) {
  2.    
  3.    
  4.   Looper.prepareMainLooper();
  5.    
  6.   ActivityThread thread = new ActivityThread();
  7.   thread.attach(false);
  8.    
  9.   if (sMainThreadHandler == null) {
  10.  
您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • 3. Oracle資料庫邏輯備份與恢復
    一. Oracle邏輯備份介紹 Oracle邏輯備份的核心就是複製數據；Oracle提供的邏輯備份與恢復的命令有exp/imp，expdp/impdp。當然像表級複製(create table table_back as select * from table)也算是一種邏輯備份。Oracle邏輯備 ...
  • Mysql清空表(truncate)與刪除表中數據(delete)的區別
    近日在做一個區塊鏈積分轉代幣的APP,牽涉到資料庫中表的記錄刪除問題, 如果一條條刪除那可真是累人。遂考慮直接進入mysql直接清空表或者刪除表中數據。 本文記錄一下這2種操作模式的區別，目標對象是表wp_comments，裡面的所有留言均是垃圾留言，均可刪除。然後便有了以下2種方式（進入mysql ...
  • 如何更有效率的去學習大數據？
    這段時間有很多人問小編如何學習大數據？ 既然這麼多人問我，那就寫篇文章，告訴大家，當然寫這篇文章也是經過思考的，不是提筆就寫，先介紹下我的基本情況，第一小編本人只是大數據中學習的小學生而已，不是什麼大牛，也不是什麼技術牛逼的神人，如果貿然動筆肯定會貽笑大方；另一方面大數據它本身領域博大精深，涵蓋之廣 ...
  • Derek解讀Bytom源碼-持久化存儲LevelDB
    作者：Derek 簡介 Github地址：https://github.com/Bytom/bytom Gitee地址：https://gitee.com/BytomBlockchain/bytom 本章介紹Derek解讀 Bytom源碼分析 持久化存儲LevelDB 作者使用MacOS操作系統，其 ...
  • OC重寫init方法
    在創建一個對象的時候我們經常會用到init方法，單單是init只能是初始化，當我們在初始化的時候想要給這個對象加上預設的東西的時候， 系統提供的init方法就不能滿足我們的需要，這時，就需要我們自己去重寫init方法； 通常在使用init方法的時候，系統先會在自己這個類中查詢是否實現（重寫）這個方法 ...
  • 一次“Error Domain=AVFoundationErrorDomain Code=-11841”的調試
    一次“Error Domain=AVFoundationErrorDomain Code= 11841”的調試 起因 最近在重構視頻輸出模塊的時候，調試碰到AVAssetReader 調用開始方法總是返回NO而失敗，代碼如下： reader的創建代碼如下，主要用的是GPUImageMovieComp ...
  • Android BottomNavigationBar導航欄
    基本屬性 setTabSelectedListener監聽器 BadgeItem標記 1.五角星標記 2.文本標記 官方all.gif view源碼下載地址 ...
  • android開發筆記：Handler、Looper、MessageQueen、Message的關係
    一、什麼是handler？ 註：線程分為主線程(主線程又叫UI線程，只能有一個主線程）和子線程（可以有多個）Handler只能在主線程里運行 handler是Android給我們提供用來更新UI的一套機制，也是一套消息處理機制，我們可以發消息，也可以通過它 處理消息。 1 2 因為android在設 ...
一周排行
    -Advertisement-
    Play Games
  • 移動開發（一）：使用.NET MAUI開發第一個安卓APP
    移動開發（一）：使用.NET MAUI開發第一個安卓APP 對於工作多年的C#程式員來說，近來想嘗試開發一款安卓APP，考慮了很久最終選擇使用.NET MAUI這個微軟官方的框架來嘗試體驗開發安卓APP，畢竟是使用Visual Studio開發工具，使用起來也比較的順手，結合微軟官方的教程進行了安卓 ...
  • wpf ToggleButton選中效果和一個登錄界面
    前言 QuestPDF 是一個開源 .NET 庫，用於生成 PDF 文檔。使用了C# Fluent API方式可簡化開發、減少錯誤並提高工作效率。利用它可以輕鬆生成 PDF 報告、發票、導出文件等。 項目介紹 QuestPDF 是一個革命性的開源 .NET 庫，它徹底改變了我們生成 PDF 文檔的方 ...
  • 彈幕樹洞項目功能新增篇
    項目地址 項目後端地址： https://github.com/ZyPLJ/ZYTteeHole 項目前端頁面地址： ZyPLJ/TreeHoleVue (github.com) https://github.com/ZyPLJ/TreeHoleVue 目前項目測試訪問地址： http://tree ...
  • 第27篇 sqlserver2022詳細安裝步驟
    話不多說，直接開乾 一.下載 1.官方鏈接下載： https://www.microsoft.com/zh-cn/sql-server/sql-server-downloads 2.在下載目錄中找到下麵這個小的安裝包 SQL2022-SSEI-Dev.exe，運行開始下載SQL server； 二. ...
  • .NET 開源高性能 MQTT 類庫
    前言 隨著物聯網（IoT）技術的迅猛發展，MQTT（消息隊列遙測傳輸）協議憑藉其輕量級和高效性，已成為眾多物聯網應用的首選通信標準。 MQTTnet 作為一個高性能的 .NET 開源庫，為 .NET 平臺上的 MQTT 客戶端與伺服器開發提供了強大的支持。 本文將全面介紹 MQTTnet 的核心功能 ...
  • Serilog文檔翻譯系列（六） - 可用的接收器、增強器、格式化輸出
    Serilog支持多種接收器用於日誌存儲，增強器用於添加屬性，LogContext管理動態屬性，支持多種輸出格式包括純文本、JSON及ExpressionTemplate。還提供了自定義格式化選項，適用於不同需求。 ...
  • 警惕 Visual Studio 屬性求值副作用導致邏輯不符合預期
    目錄簡介獲取 HTML 文檔解析 HTML 文檔測試參考文章 簡介 動態內容網站使用 JavaScript 腳本動態檢索和渲染數據，爬取信息時需要模擬瀏覽器行為，否則獲取到的源碼基本是空的。 本文使用的爬取步驟如下： 使用 Selenium 獲取渲染後的 HTML 文檔 使用 HtmlAgility ...
  • [使用目前最新版]HybridCLR6.9.0+YooAsset2.2.4實現純C# Unity熱更新方案 (一)
    1.前言 什麼是熱更新 游戲或者軟體更新時，無需重新下載客戶端進行安裝，而是在應用程式啟動的情況下，在內部進行資源或者代碼更新 Unity目前常用熱更新解決方案 HybridCLR，Xlua，ILRuntime等 Unity目前常用資源管理解決方案 AssetBundles，Addressable， ...
  • 在 ASP.NET Core Web API 中使用操作篩選器統一處理通用操作
    本文章主要是在C# ASP.NET Core Web API框架實現向手機發送驗證碼簡訊功能。這裡我選擇是一個互億無線簡訊驗證碼平臺，其實像阿裡雲，騰訊雲上面也可以。 首先我們先去 互億無線 https://www.ihuyi.com/api/sms.html 去註冊一個賬號 註冊完成賬號後，它會送 ...
  • 第28篇 如何.net中實現高效可靠數據同步api
    通過以下方式可以高效，並保證數據同步的可靠性 1.API設計 使用RESTful設計，確保API端點明確，並使用適當的HTTP方法（如POST用於創建，PUT用於更新）。 設計清晰的請求和響應模型，以確保客戶端能夠理解預期格式。 2.數據驗證 在伺服器端進行嚴格的數據驗證，確保接收到的數據符合預期格 ...
所有分類