Android之Handler消息傳遞機制詳解

時間 2019-12-08

標籤 android handler 消息傳遞機制詳解欄目 Android 简体版

原文原文鏈接

前言

在Android開發中,多線程應用是很是頻繁的,其中Handler機制隨處可見.
下面就本人對Handle的一些理解與你們一塊兒分享，共同回顧下Handle異步消息傳遞機制。

1.Handler是什麼？

Handler是一套在 Android開發中進行異步消息傳遞的機制。

2.Handler在Android中的做用

在Android開發中多線程的應用中，將工做線程中需更新UI的操做信息傳遞到 UI主線程，從而實現工做線程對UI的更新處理，最終實現異步消息的處理。

3. 咱們爲何要使用Handler去處理更新UI操做呢？

在多個線程併發更新UI的同時保證線程安全。

4.Handler異步消息傳遞所涉及的相關概念

MainThread （主線程）UI線程，程序啓動時自動建立。
工做線程，開發者本身開啓的線程，執行耗時操做等。
Handler（處理者） UI線程與子線程通訊的媒介，添加消息到消息隊列（Message Queue）處理循環器分發過來的消息（Looper）。
Message （消息） Handler接受&處理的對象，存儲須要操做的消息。
Message Queue（消息隊列） 數據存儲結構，採用先進先出方式，存儲Handler發過來的消息。
Looper（循壞器）消息隊列與處理者的媒介，從消息隊列中循環取出消息併發送給Handler處理。

5.使用方式

Handler的使用方式因發送消息到消息隊列的方式不一樣而不一樣（兩種）
使用Handler.sendMessage（）、使用Handler.post（）

1.使用 Handler.sendMessage（）方式

/** 
  * 方式1：新建Handler子類（內部類）
  */

    // 步驟1：自定義Handler子類（繼承Handler類） & 複寫handleMessage（）方法
    class mHandler extends Handler {

        // 經過複寫handlerMessage() 從而肯定更新UI的操做
        @Override
        public void handleMessage(Message msg) {
         ...// 執行UI操做
            
        }
    }

    // 步驟2：在主線程中建立Handler實例
        private Handler mhandler = new mHandler();

    // 步驟3：建立所需的消息對象
        Message msg = Message.obtain(); // 實例化消息對象
        msg.what = 1; // 消息標識
        msg.obj = "AA"; // 消息內容存放

    // 步驟4：在工做線程中 經過Handler發送消息到消息隊列中
        mHandler.sendMessage(msg);


/** 
  * 方式2：匿名內部類
  */
   // 步驟1：在主線程中 經過匿名內部類 建立Handler類對象
            private Handler mhandler = new  Handler(){
                // 經過複寫handlerMessage()
                @Override
                public void handleMessage(Message msg) {
                        ...// 需執行UI操做
                    }
            };

  // 步驟2：建立消息對象
    Message msg = Message.obtain(); // 實例化消息對象
  msg.what = 1; // 消息標識
  msg.obj = "AA"; // 消息內容存放
  // 步驟3：在工做線程中 經過Handler發送消息到消息隊列中
   mHandler.sendMessage(msg);

2.使用Handler.post（）

new Thread() {
            @Override
            public void run() {
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                // 經過psot（）發送，傳入1個Runnable對象
                mHandler.post(new Runnable() {
                    @Override
                    public void run() {
                        // 指定操做UI內容
                   
                    }

                });
            }
        }.start();

6.Handler底層原理及源碼分析

在源碼分析前，先來了解Handler機制中的幾個核心類android

處理器（Handler）
消息隊列（MessageQueue）
循環器（Looper）

關於這幾個類的具體做用前面已經介紹過了就再也不過多闡述了。segmentfault

下面開始源碼分析，注意力集中了
上文中咱們提到過Handler發送消息有兩種方式，分別是安全

Handler.sendMessage（）
使用Handler.post（）

下面先從第一種開始分析：多線程

方式1：使用 Handler.sendMessage（）

//經過匿名內部類 建立Handler類對象
    private Handler mhandler = new  Handler(){
        // 經過複寫handlerMessage()從而肯定更新UI的操做
        @Override
        public void handleMessage(Message msg) {
                ...// 需執行的UI操做
            }
    };

---------->>開始源碼分析

public Handler() {

            this(null, false);
            // ->>此處this指代的就是當前的Handler實例，調用有參構造

    }

public Handler(Callback callback, boolean async) {

            ...// 無關代碼我就不貼了

            // 1. 指定Looper對象
                mLooper = Looper.myLooper();
                if (mLooper == null) {
                    throw new RuntimeException(
                        "Can't create handler inside thread that has not called Looper.prepare()");
                }
                // Looper.myLooper()做用：獲取當前線程的Looper對象；若線程無Looper對象則拋出異常

                // 可經過執行Loop.getMainLooper()方法得到主線程的Looper對象

            // 2. 綁定消息隊列對象（MessageQueue）
                mQueue = mLooper.mQueue;
                // 獲取該Looper對象中保存的消息隊列對象（MessageQueue）
                // 至此，完成了handler 與 Looper對象中MessageQueue的關聯
    }

從上面的源碼來看，當咱們建立Handler對象後，經過Handler的構造方法系統就已經幫咱們自動綁定了looper和對應的MessageQueue消息隊列。咱們只需拿着這個Handler對象執行咱們所需的操做就能夠了
可是，你確定有疑問了，當前線程的Looper對象 & 對應的消息隊列對象（MessageQueue）是哪來的呢？我既沒有獲取也沒有建立啊？

public static void main(String[] args) {
            ... // 無關的代碼

            Looper.prepareMainLooper(); 
            // 1. 爲主線程建立1個Looper對象，同時生成1個消息隊列對象（MessageQueue）

            ActivityThread thread = new ActivityThread(); 
            // 2. 建立主線程

            Looper.loop(); 
            // 3. 自動開啓 消息循環 

        }

咱們能夠看到，其實在Android應用進程啓動時，會默認建立1個主線程（ActivityThread，也叫UI線程），建立ActivityThread的時候，會自動調用ActivityThread的1個靜態的main（）方法 = 應用程序的入口，而main（）方法內則會自動調用Looper.prepareMainLooper()爲主線程生成1個Looper對象和MessageQueue隊列。
而Handler對象建立時若不指定looper則默認綁定主線程的looper，從而能夠執行主線程的UI更新操做。
如果在子線程中建立Handler實例，則須要指定looper了，因此就用上了Loop.getMainLooper()方法來得到主線程的Looper對象。

方式1：使用Handler.post（）

public void dispatchMessage(Message msg) {

    // 1. 若msg.callback屬性不爲空，則表明使用了post（Runnable r）發送消息
    // 則執行handleCallback(msg)，即回調Runnable對象裏複寫的run（）
        if (msg.callback != null) {
            handleCallback(msg);
        } else {
            if (mCallback != null) {
                if (mCallback.handleMessage(msg)) {
                    return;
                }
            }

            // 2. 若msg.callback屬性爲空，則表明使用了sendMessage（Message msg）發送消息，即回調複寫的handleMessage(msg)
            handleMessage(msg);

        }
    }


   public void handleMessage(Message msg) {  
          ... // 建立Handler實例時複寫
   }

從以上源碼來看，使用Handler.post（）時，系統會自動回調Runnable對象裏複寫的run（）方法，將其打包成msg對象，實際上和sendMessage（Message msg）發送方式相同。併發

至此，關於Handler的異步消息傳遞機制的解析就完成了。

7.關於Handler 內存泄露的緣由

在Android開發中，內存泄露是十分常見的
其中一種狀況就是在Handler中發生的內存泄露
爲何會發生內存泄漏？

1.Handler的通常用法：新建Handler子類（內部類）、匿名Handler內部類，而在咱們編寫代碼的時候，其實編譯器就會提示咱們這種操做可能會發生內存泄漏，在android studio中就是這塊代碼會變黃。
2.提示的緣由是異步

該Handler類因爲未設置爲靜態類，從而致使了內存泄露
最終的內存泄露發生在Handler類的外部類：XXXActivity類中

3.內存泄漏的緣由
首先咱們先要了解一些其餘的知識點。async

主線程的Looper對象的生命週期 = 應該應用程序的生命週期
在Java中，非靜態內部類 & 匿名內部類都默認持有外部類的引用，

而在Handler處理消息的時候，Handler必須處理完全部消息纔會與外部類解除引用關係，若是此時外部Activity須要提早被銷燬了，而Handler因還未完成消息處理而繼續持有外部Activity的引用。因爲上述引用關係，垃圾回收器（GC）便沒法回收MainActivity，從而形成內存泄漏。ide

8.如何解決Handler內存泄漏

1.靜態內部類+弱引用

將Handler的子類設置成靜態內部類，同時，還可加上使用WeakReference弱引用持有Activity實例。
緣由：弱引用的對象擁有短暫的生命週期。在垃圾回收器線程掃描時，一旦發現了只具備弱引用的對象，無論當前內存空間足夠與否，都會回收它的內存。oop

// 設置爲：靜態內部類
    private static class FHandler extends Handler{

        // 定義 弱引用實例
        private WeakReference<Activity> reference;

        // 在構造方法中傳入需持有的Activity實例
        public FHandler(Activity activity) {
            // 使用WeakReference弱引用持有Activity實例
            reference = new WeakReference<Activity>(activity); }

        // 複寫handlerMessage() 
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case 1:
                 //更新UI
                    break;
                case 2:
                //更新UI
                    break;

            }

2.當外部l類結束生命週期時，清空Handler內消息隊列

@Override
    protected void onDestroy() {
        super.onDestroy();
        mHandler.removeCallbacksAndMessages(null);
        // 外部類Activity生命週期結束時，同時清空消息隊列 & 結束Handler生命週期
    }