分支 tin 子類 業務 順序 發送消息 ui線程 eight arr

1.消息機制概述

1.1.消息機制的簡介

　　在Android中使用消息機制，我們首先想到的就是Handler。

　　沒錯，Handler是Android消息機制的上層接口。

　　Handler的使用過程很簡單，通過它可以輕松地將一個任務切換到Handler所在的線程中去執行。

　　通常情況下，Handler的使用場景就是更新UI。

　　如下就是使用消息機制的一個簡單實例：

　　

public class Activity extends android.app.Activity {
    private Handler mHandler = new
 
 Handler(){
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            System.out.println(msg.what);
        }
    };
    @Override
    public void onCreate(Bundle savedInstanceState, PersistableBundle persistentState) {
        super
 
.onCreate(savedInstanceState, persistentState);
        setContentView(R.layout.activity_main);
        new Thread(new Runnable() {
            @Override
            public void run() {
                ...............耗時操作
                Message message = Message.obtain();
                message.what 
 
= 1;
                mHandler.sendMessage(message);
            }
        }).start();
    }
}

　　在子線程中，進行耗時操作，執行完操作後，發送消息，通知主線程更新UI。

　　這便是消息機制的典型應用場景。

　　我們通常只會接觸到Handler和Message來完成消息機制，

　　其實內部還有兩大助手來共同完成消息傳遞。

1.2.消息機制的模型

　　消息機制主要包含：MessageQueue，Handler和Looper這三大部分，以及Message，

　　下面我們一一介紹。

　　

　　**Message：**需要傳遞的消息，可以傳遞數據；

　　**MessageQueue：**消息隊列，但是它的內部實現並不是用的隊列，

　　　　實際上是通過一個單鏈表的數據結構來維護消息列表，

　　　　因為單鏈表在插入和刪除上比較有優勢。主要功能向消息池投遞消息

　　　　(MessageQueue.enqueueMessage)和取走消息池的消息(MessageQueue.next)；

　　**Handler：**消息輔助類，主要功能向消息池發送各種消息事件(Handler.sendMessage)

　　　　和處理相應消息事件(Handler.handleMessage)；

　　**Looper：**不斷循環執行(Looper.loop)，從MessageQueue中讀取消息，

　　　　按分發機制將消息分發給目標處理者。

1.3.消息機制的架構

　　**消息機制的運行流程：**在子線程執行完耗時操作，當Handler發送消息時，

　　　　將會調用MessageQueue.enqueueMessage，向消息隊列中添加消息。

　　　　當通過Looper.loop開啟循環後，會不斷地從線程池中讀取消息，即調用MessageQueue.next，

　　　　然後調用目標Handler（即發送該消息的Handler）的dispatchMessage方法傳遞消息，

　　　　然後返回到Handler所在線程，目標Handler收到消息，調用handleMessage方法，

　　　　接收消息，處理消息。

　　

　　**MessageQueue，Handler和Looper三者之間的關系：

　　**每個線程中只能存在一個Looper，Looper是保存在ThreadLocal中的。

　　主線程（UI線程）已經創建了一個Looper，所以在主線程中不需要再創建Looper，

　　但是在其他線程中需要創建Looper。

　　每個線程中可以有多個Handler，即一個Looper可以處理來自多個Handler的消息。

　　Looper中維護一個MessageQueue，

　　來維護消息隊列，消息隊列中的Message可以來自不同的Handler。　

　　

　　下面是消息機制的整體架構圖，接下來我們將慢慢解剖整個架構。

　　

　　

　　

　　

　　從中我們可以看出：

　　Looper有一個MessageQueue消息隊列；

　　MessageQueue有一組待處理的Message；

　　Message中記錄發送和處理消息的Handler；

　　Handler中有Looper和MessageQueue。

2.消息機制的源碼解析

2.1.Looper

　　要想使用消息機制，首先要創建一個Looper。

　　初始化Looper

　　無參情況下，默認調用prepare(true);

　　表示的是這個Looper可以退出，而對於false的情況則表示當前Looper不可以退出。

　　

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

    private static void prepare(boolean quitAllowed) {
        if (sThreadLocal.get() != null) {
            throw new RuntimeException("Only one Looper may be created per thread");
        }
        sThreadLocal.set(new Looper(quitAllowed));
    }

　　這裏看出，不能重復創建Looper，只能創建一個。

　　創建Looper,並保存在ThreadLocal。

　　其中ThreadLocal是線程本地存儲區（Thread Local Storage，簡稱為TLS），

　　每個線程都有自己的私有的本地存儲區域，不同線程之間彼此不能訪問對方的TLS區域。

　　開啟Looper

　　

public static void loop() {
    final Looper me = myLooper();  //獲取TLS存儲的Looper對象 
    if (me == null) {
        throw new RuntimeException("No Looper; Looper.prepare() wasn‘t called on this thread.");
    }
    final MessageQueue queue = me.mQueue;  //獲取Looper對象中的消息隊列

    Binder.clearCallingIdentity();
    final long ident = Binder.clearCallingIdentity();

    for (;;) { //進入loop的主循環方法
        Message msg = queue.next(); //可能會阻塞,因為next()方法可能會無限循環
        if (msg == null) { //消息為空，則退出循環
            return;
        }

        Printer logging = me.mLogging;  //默認為null，可通過setMessageLogging()方法來指定輸出，用於debug功能
        if (logging != null) {
            logging.println(">>>>> Dispatching to " + msg.target + " " +
                    msg.callback + ": " + msg.what);
        }
        msg.target.dispatchMessage(msg); //獲取msg的目標Handler，然後用於分發Message 
        if (logging != null) {
            logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);
        }

        final long newIdent = Binder.clearCallingIdentity();
        if (ident != newIdent) {
         
        }
        msg.recycleUnchecked(); 
    }
}

　　loop()進入循環模式，不斷重復下面的操作，直到消息為空時退出循環:

　　讀取MessageQueue的下一條Message（關於next()，後面詳細介紹）；

　　把Message分發給相應的target。

　　

　　當next()取出下一條消息時，隊列中已經沒有消息時，next()會無限循環，產生阻塞。

　　等待MessageQueue中加入消息，然後重新喚醒。

　　

　　

　　主線程中不需要自己創建Looper，這是由於在程序啟動的時候，

　　系統已經幫我們自動調用了Looper.prepare()方法。

　　查看ActivityThread中的main()方法，代碼如下所示：

　　

 public static void main(String[] args) {
..........................
        Looper.prepareMainLooper();
  ..........................
        Looper.loop();
  ..........................

    }

　　其中```prepareMainLooper()``方法會調用prepare(false)方法。

2.2.Handler

　　創建Handler

　　

public Handler() {
    this(null, false);
}

public Handler(Callback callback, boolean async) {
   .................................
    //必須先執行Looper.prepare()，才能獲取Looper對象，否則為null.
    mLooper = Looper.myLooper();  //從當前線程的TLS中獲取Looper對象
    if (mLooper == null) {
        throw new RuntimeException("");
    }
    mQueue = mLooper.mQueue; //消息隊列，來自Looper對象
    mCallback = callback;  //回調方法
    mAsynchronous = async; //設置消息是否為異步處理方式
}

　　對於Handler的無參構造方法，默認采用當前線程TLS中的Looper對象，

　　並且callback回調方法為null，且消息為同步處理方式。

　　只要執行的Looper.prepare()方法，那麽便可以獲取有效的Looper對象。

　　

　

2.3.發送消息

　　發送消息有幾種方式，但是歸根結底都是調用了sendMessageAtTime()方法。

　　在子線程中通過Handler的post()方式或send()方式發送消息，

　　最終都是調用了sendMessageAtTime()方法。

　　post方法

　　

 public final boolean post(Runnable r)
    {
       return  sendMessageDelayed(getPostMessage(r), 0);
    }
public final boolean postAtTime(Runnable r, long uptimeMillis)
    {
        return sendMessageAtTime(getPostMessage(r), uptimeMillis);
    }
 public final boolean postAtTime(Runnable r, Object token, long uptimeMillis)
    {
        return sendMessageAtTime(getPostMessage(r, token), uptimeMillis);
    }
 public final boolean postDelayed(Runnable r, long delayMillis)
    {
        return sendMessageDelayed(getPostMessage(r), delayMillis);
    }

　　send方法

　　

public final boolean sendMessage(Message msg)
    {
        return sendMessageDelayed(msg, 0);
    }
 public final boolean sendEmptyMessage(int what)
    {
        return sendEmptyMessageDelayed(what, 0);
    } 
public final boolean sendEmptyMessageDelayed(int what, long delayMillis) {
        Message msg = Message.obtain();
        msg.what = what;
        return sendMessageDelayed(msg, delayMillis);
    }
 public final boolean sendEmptyMessageAtTime(int what, long uptimeMillis) {
        Message msg = Message.obtain();
        msg.what = what;
        return sendMessageAtTime(msg, uptimeMillis);
    }
 public final boolean sendMessageDelayed(Message msg, long delayMillis)
    {
        if (delayMillis < 0) {
            delayMillis = 0;
        }
        return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
    }

　　就連子線程中調用Activity中的runOnUiThread()中更新UI，

　　其實也是發送消息通知主線程更新UI，最終也會調用sendMessageAtTime()方法。

　　

public final void runOnUiThread(Runnable action) {
        if (Thread.currentThread() != mUiThread) {
            mHandler.post(action);
        } else {
            action.run();
        }
    }

　　如果當前的線程不等於UI線程(主線程)，就去調用Handler的post()方法，

　　最終會調用sendMessageAtTime()方法。

　　否則就直接調用Runnable對象的run()方法。

　　下面我們就來一探究竟，到底sendMessageAtTime()方法有什麽作用？

　　sendMessageAtTime()

　　

public boolean sendMessageAtTime(Message msg, long uptimeMillis) {
       //其中mQueue是消息隊列，從Looper中獲取的
        MessageQueue queue = mQueue;
        if (queue == null) {
            RuntimeException e = new RuntimeException(
                    this + " sendMessageAtTime() called with no mQueue");
            Log.w("Looper", e.getMessage(), e);
            return false;
        }
        //調用enqueueMessage方法
        return enqueueMessage(queue, msg, uptimeMillis);
    }


 private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
        msg.target = this;
        if (mAsynchronous) {
            msg.setAsynchronous(true);
        }
        //調用MessageQueue的enqueueMessage方法
        return queue.enqueueMessage(msg, uptimeMillis);
    }

　　

　　可以看到sendMessageAtTime()方法的作用很簡單，就是調用MessageQueue的enqueueMessage()方法

　　往消息隊列中添加一個消息。

　　下面來看enqueueMessage()方法的具體執行邏輯。

　　enqueueMessage()

　　

boolean enqueueMessage(Message msg, long when) {
    // 每一個Message必須有一個target
    if (msg.target == null) {
        throw new IllegalArgumentException("Message must have a target.");
    }
    if (msg.isInUse()) {
        throw new IllegalStateException(msg + " This message is already in use.");
    }
    synchronized (this) {
        if (mQuitting) {  //正在退出時，回收msg，加入到消息池
            msg.recycle();
            return false;
        }
        msg.markInUse();
        msg.when = when;
        Message p = mMessages;
        boolean needWake;
        if (p == null || when == 0 || when < p.when) {
            //p為null(代表MessageQueue沒有消息） 或者msg的觸發時間是隊列中最早的， 則進入該該分支
            msg.next = p;
            mMessages = msg;
            needWake = mBlocked; 
        } else {
            //將消息按時間順序插入到MessageQueue。一般地，不需要喚醒事件隊列，除非
            //消息隊頭存在barrier，並且同時Message是隊列中最早的異步消息。
            needWake = mBlocked && p.target == null && msg.isAsynchronous();
            Message prev;
            for (;;) {
                prev = p;
                p = p.next;
                if (p == null || when < p.when) {
                    break;
                }
                if (needWake && p.isAsynchronous()) {
                    needWake = false;
                }
            }
            msg.next = p;
            prev.next = msg;
        }
        if (needWake) {
            nativeWake(mPtr);
        }
    }
    return true;
}

　　MessageQueue是按照Message觸發時間的先後順序排列的，隊頭的消息是將要最早觸發的消息。

　　當有消息需要加入消息隊列時，會從隊列頭開始遍歷，直到找到消息應該插入的合適位置，

　　以保證所有消息的時間順序。

2.4.獲取消息

　　當發送了消息後，在MessageQueue維護了消息隊列，

　　然後在Looper中通過loop()方法，不斷地獲取消息。

　　上面對loop()方法進行了介紹，其中最重要的是調用了queue.next()方法,

　　通過該方法來提取下一條信息。

　　面我們來看一下next()方法的具體流程。

　　next()

　　

Message next() {
    final long ptr = mPtr;
    if (ptr == 0) { //當消息循環已經退出，則直接返回
        return null;
    }
    int pendingIdleHandlerCount = -1; // 循環叠代的首次為-1
    int nextPollTimeoutMillis = 0;
    for (;;) {
        if (nextPollTimeoutMillis != 0) {
            Binder.flushPendingCommands();
        }
        //阻塞操作，當等待nextPollTimeoutMillis時長，或者消息隊列被喚醒，都會返回
        nativePollOnce(ptr, nextPollTimeoutMillis);
        synchronized (this) {
            final long now = SystemClock.uptimeMillis();
            Message prevMsg = null;
            Message msg = mMessages;
            if (msg != null && msg.target == null) {
                //當消息Handler為空時，查詢MessageQueue中的下一條異步消息msg，為空則退出循環。
                do {
                    prevMsg = msg;
                    msg = msg.next;
                } while (msg != null && !msg.isAsynchronous());
            }
            if (msg != null) {
                if (now < msg.when) {
                    //當異步消息觸發時間大於當前時間，則設置下一次輪詢的超時時長
                    nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);
                } else {
                    // 獲取一條消息，並返回
                    mBlocked = false;
                    if (prevMsg != null) {
                        prevMsg.next = msg.next;
                    } else {
                        mMessages = msg.next;
                    }
                    msg.next = null;
                    //設置消息的使用狀態，即flags |= FLAG_IN_USE
                    msg.markInUse();
                    return msg;   //成功地獲取MessageQueue中的下一條即將要執行的消息
                }
            } else {
                //沒有消息
                nextPollTimeoutMillis = -1;
            }
         //消息正在退出，返回null
            if (mQuitting) {
                dispose();
                return null;
            }
            ...............................
    }
}

　　nativePollOnce是阻塞操作，其中nextPollTimeoutMillis代表下一個消息到來前，

　　還需要等待的時長；

　　當nextPollTimeoutMillis = -1時，表示消息隊列中無消息，會一直等待下去。

　　可以看出next()方法根據消息的觸發時間，獲取下一條需要執行的消息,

　　隊列中消息為空時，則會進行阻塞操作。

2.5.分發消息

　　

　　在loop()方法中，獲取到下一條消息後，

　　執行msg.target.dispatchMessage(msg)，來分發消息到目標Handler對象。

　　

　　dispatchMessage()

　　

public void dispatchMessage(Message msg) {
    if (msg.callback != null) {
        //當Message存在回調方法，回調msg.callback.run()方法；
        handleCallback(msg);
    } else {
        if (mCallback != null) {
            //當Handler存在Callback成員變量時，回調方法handleMessage()；
            if (mCallback.handleMessage(msg)) {
                return;
            }
        }
        //Handler自身的回調方法handleMessage()
        handleMessage(msg);
    }
}

　

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

　　

　　分發消息流程：

　　當Message的msg.callback不為空時，則回調方法msg.callback.run();

　　當Handler的mCallback不為空時，則回調方法mCallback.handleMessage(msg)；

　　
　　最後調用Handler自身的回調方法handleMessage()，該方法默認為空，

　　　　Handler子類通過覆寫該方法來完成具體的邏輯。

　　消息分發的優先級：

　　
　　Message的回調方法：message.callback.run()，優先級最高；

　　Handler中Callback的回調方法：Handler.mCallback.handleMessage(msg)，優先級僅次於1；

　　Handler的默認方法：Handler.handleMessage(msg)，優先級最低。

　　對於很多情況下，消息分發後的處理方法是第3種情況，即Handler.handleMessage()，

　　　　一般地往往通過覆寫該方法從而實現自己的業務邏輯。

3.總結

　　以上便是消息機制的原理，以及從源碼角度來解析消息機制的運行過程。

　　可以簡單地用下圖來理解。

　　

4.參考文章

本文參考自：

https://github.com/LRH1993/android_interview/blob/master/android/basis/message-mechanism.md

Android 面試收集錄5 消息機制