Android消息機制源碼分析

本篇主要介紹Android中的消息機制，即Looper、Handler是如何協同工作的；

Looper：主要用來管理當前線程的消息隊列，每個線程只能有一個Looper

Handler：用來將消息（Message）插入到當前線程的消息隊列，並負責分發Looper中的消息，將消息發送到當前線程執行

具體關系圖如下所示：

接下來我們來分析一下Looper和Handler的源碼，了解一下其中的奧妙。

首先我們從一個程序運行的入口來分析，源碼如下：

public static void main(String[] args){
    
    ......
    Looper.prepareMainLooper();//初始化Looper
    
    ......
    if(smainThreadHandler==null){
    smainThreadHandler=thread.getHandler();//初始化Handler
    }
    
    ......
    
    Looper.loop();//消息循環執行
    }

可以看出，程序在運行的時候首先會創建主線程的Looper對象，並通過Looper開啟消息循環，不停的取出消息並執行；

接下來我們來研究Looper的源碼；

第一部分：Looper源碼

初始化

 private Looper(boolean quitAllowed) {
        mQueue = new MessageQueue(quitAllowed);
        mThread = Thread.currentThread();
    }
    
    初始化Looper對象（該過程包含初始化消息隊列和當前線程對象）
    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在初始化的時候，首先會創建消息隊列，並通過sThreadLocal保存在當前的線程本地變量中；

再來看一下程序入口Looper.prepareMainLooper();//初始化Looper究竟執行了什么

//初始化主線程的Looper對象
     public static void prepareMainLooper() {
        prepare(false);
        synchronized (Looper.class) {
            if (sMainLooper != null) {
                throw new IllegalStateException("The main Looper has already been prepared.");
            }
            sMainLooper = myLooper();
        }
    }

這里有兩行關鍵的代碼：prepare(false);和sMainLooper = myLooper();

首先我們來看prepare(false);即上面講到的 初始化Looper，可以看看上面的源碼；

我們來看sMainLooper = myLooper();

 

 public static @Nullable Looper myLooper() {
        return sThreadLocal.get();
    }

 

非常簡單，我們上面提到在初始化Looper的時候會把Looper保存到當前線程的本地變量中，而這行代碼的意思

就是從線程本地變量中將looper取出來

有了Looper，程序怎樣才能運行？答案就在Looper.loop();//消息循環執行

 public static void loop() {
        final Looper me = myLooper();//得到當前線程的Looper對象
        if (me == null) {
            throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
        }
        final MessageQueue queue = me.mQueue;//得到消息隊列

      ......

      //執行消息循環
        for (;;) {
            Message msg = queue.next(); // might block
            if (msg == null) {
                // No message indicates that the message queue is quitting.
                return;
            }
            msg.target.dispatchMessage(msg);
            msg.recycleUnchecked();
        }
    }

顯而易見，loop方法就是獲取到當前線程的Looper對象，並從中循環取出消息，並執行，程序就這樣跑起來了，具體是如何分發消息的

我們將會在下面講解；

 

至此我們至少應該明白，當主線程在執行的時候

1、初始化Looper，並將Looper保存的線程變量中

2、Looper在初始化的時候會創建消息隊列，並管理消息隊列

2、取出Looper，並從消息隊列中取出消息，循環執行

 

第二部分：Handler源碼

 

我們知道Handler有兩種使用方式，一種是使用handler.post(Runnable r);另一種是復寫handleMessage(Message msg)方法

復寫handleMessage(Message msg)方法非常簡單，Handler在消息分發的時候，直接回調該方法即可，我們主要來研究第一種

 

public final boolean post(Runnable r)
    {
       return  sendMessageDelayed(getPostMessage(r), 0);
    }

 

看到這個我們首先得明白getPostMessage(r)干了什么

 

 

private static Message getPostMessage(Runnable r) {
        Message m = Message.obtain();
        m.callback = r;
        return m;
    }

 

可以看出是將r封裝成了一個消息，r作為該消息的回調；

我們接着看：

public final boolean sendMessageDelayed(Message msg, long delayMillis)
    {
        if (delayMillis < 0) {
            delayMillis = 0;
        }
        return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
    }

關鍵代碼在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);
    }

這段代碼主要就是獲取到消息隊列，有了消息隊列我們接着看enqueueMessage(queue, msg, uptimeMillis);

 

//handler和msg建立關聯
    private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
        msg.target = this;
        if (mAsynchronous) {
            msg.setAsynchronous(true);
        }
        return queue.enqueueMessage(msg, uptimeMillis);
    }

 

 msg.target = this;這里將msg的target指向自己，msg的target只能是this
最后相信大家也看出來了，接下來就是真正將msg插入到消息隊列了

//負責將msg插入到消息隊列
     boolean enqueueMessage(Message msg, long when) {
        if (msg.target == null) {
            throw new IllegalArgumentException("Message must have a target.");
        }

        synchronized (this) {
         //將msg插入到消息隊列
        
            msg.when = when;
            Message p = mMessages;
            boolean needWake;
            //消息隊列為鏈式存儲 如果消息隊列中的消息為0，將msg插入到第一個，並新建一個message對象，將
            //msg對象的next指向新建的message 等待新msg插入
            if (p == null || when == 0 || when < p.when) {
                // New head, wake up the event queue if blocked.
                msg.next = p;
                mMessages = msg;
                needWake = mBlocked;
            } else {
            //將msg插入到隊尾
                for (;;) {
                    prev = p;
                    p = p.next;
                    if (p == null || when < p.when) {
                        break;
                    }
                    if (needWake && p.isAsynchronous()) {
                        needWake = false;
                    }
                }
                msg.next = p; // invariant: p == prev.next
                prev.next = msg;
            }

          
        }
        return true;
    }

繞了這么大一圈，最后是通過Handler中的消息隊列，將消息成功插入隊尾，至此handler在post的時候實際上

是將r封裝成了一個msg並插入到消息隊列；

另外這里再提一下Handler第二種方式即復寫handleMessage(Message msg)方法使用

handler.sendMessage(msg);

其源代碼其實就是執行以上的

public final boolean sendMessageDelayed(Message msg, long delayMillis)
    {
        if (delayMillis < 0) {
            delayMillis = 0;
        }
        return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
    }

重復以上一系列過程，將msg插入到消息隊列；

最后我們來看一下比較關鍵的消息分發，消息分發是在以上Looper源碼的loop方法中核心方法是：

 msg.target.dispatchMessage(msg);

我們知道msg的target只能是Handler本身，因此消息分發是在Handler中來完成的；

  /**
     * Handle system messages here.
     */
    public void dispatchMessage(Message msg) {
        if (msg.callback != null) {
            handleCallback(msg);
        } else {
            if (mCallback != null) {
                if (mCallback.handleMessage(msg)) {
                    return;
                }
            }
            handleMessage(msg);
        }
    }

第一：if (msg.callback != null)  如果你傳入了callback即Runnable，那么就執行 handleCallback(msg);

即調用r的run方法，通常是handler.post(r);類型的

第二：if (mCallback != null)這種方法允許讓activity等來實現Handler.Callback接口，避免了自己編寫handler重寫handleMessage方法。

第三：handleMessage(msg); 即handler.sendMessage(msg);時調用的。直接回調Handler的handleMessage(msg);方法

至此，Android中的消息機制Looper和Handler相信你已經有了一定的了解；

最后我們再來總結一下

1、Looper 一個線程中只能有一個Looper，用來管理消息隊列

2、Looper從消息隊列里取出msg，交給Handler來進行分發，分發到Handler所在的線程執行，即創建Handler時的線程；

3、可以在當前線程中創建消息對象或直接復寫Runnable的run方法，同過Handler將msg和r封裝后的msg插入到消息隊列