Android消息機制Handler

不忘初心 砥礪前行, Tomorrow Is Another Day !html

本文概要:android

  1. 對於Handler兩個常見的問題
  2. messageQueue、Looper、Handler之間的關係

前言:安全

Android的消息機制主要是指Handler運行機制,handler它的做用就是切換到指定線程執行任務,記住是切換到指定線程執行任務,能夠子線程也能夠是主線程,只是在實際開發中常常應用於更新UI.在handler底層須要MessageQueue與Looper支持.接着咱們來具體介紹.bash

一. 兩個常見問題:

  1. android爲何不容許在子線程更新UI?
爲了不多線程,更新UI線程是不安全的.
複製代碼
  1. 線程不安全,對UI訪問爲何不採用鎖的機制?
鎖機制會形成邏輯複雜而且下降訪問UI的效率,阻塞某些線程的執行.
複製代碼

二. messageQueue、Looper、Handler之間的關係

  • messageQueue:存儲消息
  • looper: 處理消息,存儲在ThreadLocal中.
  • Handler: 是基於looper構建內部消息循環系統.

對於ThreadLocal若是暫不瞭解,能夠先閱讀三. 線程管理之ThreadLocal,這樣更容易理解Handler消息機制.多線程

接下來咱們看三劍客的各自工做原理,首先看messageQueue.async

messageQueue

messageQueue稱爲消息隊列,用來存儲消息.它涉及到兩個關鍵操做一個就是將消息插入消息隊列,另外一個就是讀取消息而且移除該消息.ide

涉及的兩個操做的方法oop

  • enqueueMessage: 插入消息
  • next: 讀取消息接着移除消息

這裏重點說下next方法,它是一個無線循環的方法,會不斷的從消息隊列中讀取消息而且移除,若是此時無消息,那麼將會一直處於阻塞中.post

對於messageQueue暫時瞭解到這裏,接着看Looper,下面還會涉及到消息隊列.學習

Looper

Looper稱爲消息循環,在消息機制中扮演着很重要的角色. 不斷的從消息隊列中獲取新消息.有消息就處理,無消息也一直處於阻塞中.

1. 首先看Looper的構造方法.

對應源碼

private Looper(boolean quitAllowed) {
        //初始化一個消息隊列
        mQueue = new MessageQueue(quitAllowed);
        //獲取當前線程
        mThread = Thread.currentThread();
}
複製代碼

上面looper的構造方法是一個private修飾,因此通常狀況不能直接調用,系統提供了prepare()方法來建立Looper.

對應源碼

public static void prepare() {
        prepare(true);
}

private static void prepare(boolean quitAllowed) {
        if (sThreadLocal.get() != null) {
            //說明一個線程只能綁定一個looper
            throw new RuntimeException("Only one Looper may be created per thread");
        }
        //將Looper保存於ThreadLocal中.
        sThreadLocal.set(new Looper(quitAllowed));
}
複製代碼

對於主線程的特殊性,系統還提供了prepareMainLooper( )來初始化Looper,其主要供ActivityThread使用.而且系統還提供了getMainLooper( )方法,這樣就能夠在任何地方獲取主線程的looper.

2. 接着看Looper的loop方法.

對應源碼

public static void loop() {
        final Looper me = myLooper();
        if (me == null) {
            //1.獲取當前線程的looper,沒有直接報錯.
            throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
        }
        final MessageQueue queue = me.mQueue;

        // Make sure the identity of this thread is that of the local process,
        // and keep track of what that identity token actually is.
        Binder.clearCallingIdentity();
        final long ident = Binder.clearCallingIdentity();

        for (;;) {
           /*
            * 2.調用MessageQueue的next獲取消息.
            * (很是重要)
            */
            Message msg = queue.next(); // might block
            if (msg == null) {//跳出循環
                // No message indicates that the message queue is quitting.
                return;
            }

            // This must be in a local variable, in case a UI event sets the logger
            final Printer logging = me.mLogging;
            if (logging != null) {
                logging.println(">>>>> Dispatching to " + msg.target + " " +
                        msg.callback + ": " + msg.what);
            }

            final long slowDispatchThresholdMs = me.mSlowDispatchThresholdMs;

            final long traceTag = me.mTraceTag;
            if (traceTag != 0 && Trace.isTagEnabled(traceTag)) {
                Trace.traceBegin(traceTag, msg.target.getTraceName(msg));
            }
            final long start = (slowDispatchThresholdMs == 0) ? 0 : SystemClock.uptimeMillis();
            final long end;
            try {
                //3. (很是重要)調用handler分發處理消息
                msg.target.dispatchMessage(msg);
                end = (slowDispatchThresholdMs == 0) ? 0 : SystemClock.uptimeMillis();
            } finally {
                if (traceTag != 0) {
                    Trace.traceEnd(traceTag);
                }
            }
            //...省略部分代碼
        }
    }
複製代碼

loop方法表明開啓消息循環,具體流程能夠看註釋這樣更清晰.這裏特別提一點,須要注意的loop是一個無限循環,不斷的從messageQueue中獲取消息,在以前咱們已經瞭解到next獲取消息時,若是沒有則一直處於阻塞狀態,因此這裏一樣也是處於阻塞狀態.只有當msg爲null的時候纔會退出,因此在自定義looper時須要在適當的時候,調用quit/quitSafely退出looper.也間接的退出了messageQueue.能夠看下面源碼.

對應源碼

public void quit() {
        //調用了MessageQueue
        mQueue.quit(false);
}

public void quitSafely() {
        mQueue.quit(true);
}

複製代碼

另外在分發消息時,回調了Handler的dispatchMessage,此方法是在建立handler所使用的Looper中去執行的,而looper又與當前線程相綁定的.也就順利的切換到指定線程去執行處理任務了.

關於Looper咱們分析到這裏,最後總結下Looper幾個比較重要的API.

  • Looper.prepare(): 建立looper
  • Looper.loop(): 開啓消息循環
  • Looper.quit/quitSafely: 當即退出/安全退出
    • 當looper退出後,經過handler發送消失會失敗,send方法會返回false.
handler工做原理

經過前面對MessageQueue與Looper的瞭解,咱們能夠用一句話總結出三者關係:"Handler依賴Looper(獲取當前線程的Looper),而Looper則依賴於MessageQueue(實例化Looper時會同時實例化一個MessageQueue)"

1. handler 準備階段

咱們知道Handler依賴於當前線程的Looper,而在主線程咱們並無手動建立looper,其實在主線程啓動時也就是ActivityThread,已經初始化了一個looper,而且開啓了消息循環.

對應源碼

public static void main(String[] args) {
        
        //...省略部分代碼
        final File configDir = Environment.getUserConfigDirectory(UserHandle.myUserId());
        TrustedCertificateStore.setDefaultUserDirectory(configDir);

        Process.setArgV0("<pre-initialized>");
        //建立Looper
        Looper.prepareMainLooper();

        ActivityThread thread = new ActivityThread();
        thread.attach(false);

        if (sMainThreadHandler == null) {
            sMainThreadHandler = thread.getHandler();
        }

        if (false) {
            Looper.myLooper().setMessageLogging(new
                    LogPrinter(Log.DEBUG, "ActivityThread"));
        }

        // End of event ActivityThreadMain.
        Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
        //開啓消息循環
        Looper.loop();

        throw new RuntimeException("Main thread loop unexpectedly exited");
    }
複製代碼

如上源碼,一切準備工做都以就緒,咱們就能夠盡情使用handler了.

2. handler 發送階段

當咱們建立Handler時,會檢查當前線程是否包含Looper.

對應源碼

public Handler(Callback callback, boolean async) {
        if (FIND_POTENTIAL_LEAKS) {
            final Class<? extends Handler> klass = getClass();
            if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) &&
                    (klass.getModifiers() & Modifier.STATIC) == 0) {
                Log.w(TAG, "The following Handler class should be static or leaks might occur: " +
                    klass.getCanonicalName());
            }
        }
        
        //獲取當前線程的Looper
        mLooper = Looper.myLooper();
        if (mLooper == null) {
            throw new RuntimeException(
                "Can't create handler inside thread that has not called Looper.prepare()");
        }
        mQueue = mLooper.mQueue;
        mCallback = callback;
        mAsynchronous = async;
    }
複製代碼

若是準備工做一切都沒問題,那麼就可使用handler發送消息了.

對應源碼

//經過Send發送普通消息
public final boolean sendMessage(Message msg){
        return sendMessageDelayed(msg, 0);
}

//經過Post發送Runnable消息
public final boolean post(Runnable r){
       return  sendMessageDelayed(getPostMessage(r), 0);
}
public final boolean sendMessageDelayed(Message msg, long delayMillis) {
        if (delayMillis < 0) {
            delayMillis = 0;
        }
        return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
}

public boolean sendMessageAtTime(Message msg, long uptimeMillis) {
        MessageQueue queue = mQueue;
        if (queue == null) {
            RuntimeException e = new RuntimeException(
                    this + " sendMessageAtTime() called with no mQueue");
            Log.w("Looper", e.getMessage(), e);
            return false;
        }
        return enqueueMessage(queue, msg, uptimeMillis);
}

private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
        //賦值msg.target=handler.
        msg.target = this;
        if (mAsynchronous) {
            msg.setAsynchronous(true);
        }
        return queue.enqueueMessage(msg, uptimeMillis);
}
複製代碼

從上面源碼可知,不管是Send仍是Post,最終都是經過send方法將消息發送出去,而且發送消息僅僅往消息隊列中插入了一條消息而已.

3. handler 處理階段

當咱們往消息隊列中插入一條消息時,此時looper從MessageQueue中獲取到新消息,就進入消息處理階段.調用了handler的dispatchMessage方法進行處理.

對應源碼

public void dispatchMessage(Message msg) {
       
        if (msg.callback != null) {//說明是一個Post消息
          //callback爲POST方法傳遞的Runnable對象
            handleCallback(msg);
        } else {//說明是一個普通消息
            if (mCallback != null) { //mCallback是個接口,提供一個建立時不須要派生handler子類.參考構造方法
                if (mCallback.handleMessage(msg)) {
                    return;
                }
            }
            //回調自身的handleMessage方法
            handleMessage(msg);
        }
    }
複製代碼

最後咱們對Hanlder流程作一個總結.

  • handler 準備階段
    1. 線程啓動時,Looper.prepare() 建立一個Looper,經過ThreadLocal將Looper對象和當前線程綁定.
    2. Looper.loop() 方法開啓消息循環,不斷從MessageQueue的中讀取消息,如沒有消息,則處於阻塞狀態.
  • handler 發送階段
    1. 當Handle建立時,會得到當前線程相關的Looper對象.

    2. 當經過Handle發送消息時,不管是Post仍是Send普通消息,僅僅加入一條消息到MessageQueue.

    3. looper經過MessageQueue的next方法獲取新消息後,而後處理這個消息,最終looper會交由Handler的dispatchMessage方法.

  • handler 處理階段
    1. 若是是Post消息,則回調Runnable的run方法.

    2. 若是是普通消息,則回調mCallback的handleMessage或自身的HandleMessage方法.

三. 在自定義Thread中使用hanlder

此外經過以上流程分析,咱們能夠知道若是在某些特殊狀況須要在子線程使用handler.那麼只須要爲其線程建立looper,開啓消息循環.這樣再其餘地方發送的消息都將在此線程中執行.

示例代碼

//僞代碼
 new Thread(){
            @Override
            public void run() {
                Looper.prepare();
                Handler handler = new Handler();
                Looper.loop();
            }
        }.start();
複製代碼

四. Handler機制的擴展

爲了更加方便使用Handler,Androi系統提供了兩種方式.具體使用筆記簡單就不講述了,直接看源碼.

  • Activity.runOnUiThread(Runnable)

對應源碼

public final void runOnUiThread(Runnable action) {
        if (Thread.currentThread() != mUiThread) {
            //發送Post消息
            mHandler.post(action);
        } else {
            //直接執行任務
            action.run();
        }
}
複製代碼
  • View.post(Runnable)

對應源碼

public boolean post(Runnable action) {
        final AttachInfo attachInfo = mAttachInfo;
        if (attachInfo != null) {
            //直接經過handler發送Post消息
            return attachInfo.mHandler.post(action);
        }

        //先加入隊列,等attachInfo被賦值時,會經過handler發送消息.
        getRunQueue().post(action);
        return true;
    }
複製代碼

最後用一張Handler工做原理圖結束本文.

Handler工做原理

因爲本人技術有限,若有錯誤的地方,麻煩你們給我提出來,本人不勝感激,你們一塊兒學習進步.

參考連接:

相關文章
相關標籤/搜索