Android消息处理机制（Handler、Looper、MessageQueue）
mochihanbing
8年前
<h3><strong>概述</strong></h3> <p>Android是基础消息驱动的，Android系统为每一个程序维护了一个消息队列（ MessageQueue ），我们可以非常简单的往消息队列中插入消息（ Handler ），主线程会循环的从队列中取出消息（ Looper ），然后交给消息的发送者来执行（ Handler ），这样就实现了通过消息来驱动程序的执行。</p> <p>这篇文章会详情分析android的消息处理机制，为了让理解更加简单，我们将从日常应用中最常见的情景---子线程中返回了数据，通过handler更新UI开始。</p> <p>大家都知道在子线程中通过handler来更新UI的步骤吧</p> <ul> <li>创建handler</li> <li>用handler发送消息</li> <li>用handler处理消息（收到消息，更新UI）</li> </ul> <p>what? 好像就用handler就完了，说好的Looper、MessageQueue呢？别急，先来看看Handler的创建</p> <pre> <code class="language-java">public Handler() { this(null, false); }</code></pre> <p>再来看看调用的这个this()</p> <pre> <code class="language-java">public Handler(Callback callback, boolean async) { ......... mLooper = Looper.myLooper(); if (mLooper == null) { throw new RuntimeException( "Can't create whitout Looper");} mQueue = mLooper.mQueue; ....... }</code></pre> <p>首先通过 Looper 的静态方法获取对应的 looper ，如果为空，直接抛出异常，由此可以看出消息处理确定是需要 looper 的。这里你可能会有疑问，这个looper是怎么来的？</p> <pre> <code class="language-java">public static @Nullable Looper myLooper() { return sThreadLocal.get();}</code></pre> <pre> <code class="language-java">public T get() { Thread t = Thread.currentThread(); ThreadLocalMap map = getMap(t); if (map != null) { ThreadLocalMap.Entry e = map.getEntry(this); if (e != null) return (T)e.value; } return setInitialValue(); }</code></pre> <p>原来是通过 ThreadLocal 的 get 方法从 ThreadLocalMap 链表中以当前线程作为 key ，取出的 value 就是我们需要的 looper ，这里的ThreadLocal和ThreadLocalMap我们等下再说。</p> <p>简单点就是线程中维护了一个HashMap用来存取looper，这里你可能又有疑问了，既然是map表，我们都没有做存looper的操作，那取出来肯定是空啊，那为什么我们创建handler的时候没有出现异常呢？</p> <p>其实，这是因为程序的主线程（UI线程）在启动的时候，就创建了looper并存入了ThreadLocalMap中。</p> <pre> <code class="language-java">public static void main(String[] args) { ...... Looper.prepareMainLooper(); ActivityThread thread = new ActivityThread(); thread.attach(false); if (sMainThreadHandler == null) { sMainThreadHandler = thread.getHandler(); } ........ Looper.loop();}</code></pre> <p><strong>Looper</strong></p> <p>来看下looper是怎么创建的</p> <pre> <code class="language-java">public static void prepareMainLooper() { //创建一个looper并存入ThreadlocalMap中 prepare(false); synchronized (Looper.class) { if (sMainLooper != null) { throw new IllegalStateException("The main Looper has already been prepared."); } //取出创建好的looper sMainLooper = myLooper(); } }</code></pre> <pre> <code class="language-java">private static void prepare(boolean quitAllowed) { if (sThreadLocal.get() != null) { throw new RuntimeException("Only one Looper may be created per thread"); } //存入ThreadLocalMap中 sThreadLocal.set(new Looper(quitAllowed)); }</code></pre> <p>通过 prepare() 方法创建一个looper，在通过 myLooper() 方法取出来。再来看看Looper的构造</p> <pre> <code class="language-java">private Looper(boolean quitAllowed) { //构造一个消息队列，复制给mQueue变量 mQueue = new MessageQueue(quitAllowed); mThread = Thread.currentThread(); }</code></pre> <p>看到这里是不是有一点眉目了？构造 looper 的同时构造了 MessageQueue ，构造 Handler 的时候获取当前线程的 looper 同时获取到了 消息队列 ，这样消息机制就联系起来了。</p> <p><strong>消息循环</strong></p> <p>现在消息机制的三大主力（Handler、Looper、MessageQueue）都具备了，那handle是怎么发送消息，looper又是怎么取出消息，消息又是怎么被处理的呢？来看看Looper.loop()方法：</p> <pre> <code class="language-java">public static void loop() { final Looper me = myLooper(); 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) { return; } msg.target.dispatchMessage(msg); ..... } }</code></pre> <p>这个函数就是不断的从消息队列 mQueue 中去取下一个要执行的消息，如果消息为空就退出循环 (其实msg永远不会为空，因为Message.next()也是一个for无限循环，里面判断如果msg==null，continue继续下一次循环) ，不为空就调用 target 的 dispatchMessage() 来执行消息， target 是一个 Handler ，也就是发送这个消息的 handler ，在后续消息发送中我们会看到targer是在哪里赋值的。</p> <p>这个函数最重要的逻辑是 queue.next() ，它是在MessageQueue中实现的，用来取出消息队列中的消息</p> <pre> <code class="language-java">Message next() { final long ptr = mPtr; if (ptr == 0) { return null; } int pendingIdleHandlerCount = -1; // -1 only during first iteration //消息队列等待时长 int nextPollTimeoutMillis = 0; for (;;) { if (nextPollTimeoutMillis != 0) { Binder.flushPendingCommands(); } //这是一个JNI方法,检查消息队列,取出消息并复制给mMessages nativePollOnce(ptr, nextPollTimeoutMillis); synchronized (this) { final long now = SystemClock.uptimeMillis(); Message prevMsg = null; Message msg = mMessages; if (msg != null && msg.target == null) { . 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 { //否则就返回消息给looper处理 mBlocked = false; if (prevMsg != null) { prevMsg.next = msg.next; } else { mMessages = msg.next; } msg.next = null; if (DEBUG) Log.v(TAG, "Returning message: " + msg); msg.markInUse(); return msg; } } else { // 如果消息队列中没有任何就无限等待，直到下一个消息到来，并唤醒消息队列 nextPollTimeoutMillis = -1; } if (pendingIdleHandlerCount <= 0) { // No idle handlers to run. Loop and wait some more. mBlocked = true; continue; } ....... pendingIdleHandlerCount = 0; nextPollTimeoutMillis = 0; } }</code></pre> <p>这个函数稍长，我们把它分解来看。</p> <p>执行下面的JNI函数会检查队列中是否有消息， nextPollTimeoutMillis 表示队列要等待的时间，初始为0，则不需要等待</p> <pre> <code class="language-java">nativePollOnce(ptr, nextPollTimeoutMillis);</code></pre> <p>等这个函数完成返回后，看消息队列中是否有消息</p> <pre> <code class="language-java">if (msg != null) { if (now < msg.when) { //如果当前时间小于消息的执行时间，消息队列等待 nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE); } else { //否则就返回消息给looper处理 mBlocked = false; if (prevMsg != null) { prevMsg.next = msg.next; } else { mMessages = msg.next; } msg.next = null; if (DEBUG) Log.v(TAG, "Returning message: " + msg); msg.markInUse(); return msg; } }</code></pre> <p>如果有消息，并且消息的执行时间大于当前时间， nextPollTimeoutMillis 重新赋值，等下一次 nativePollOnce(ptr, nextPollTimeoutMillis); 执行的时候就要等待到执行时间了。</p> <pre> <code class="language-java">nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);</code></pre> <p>否则，就直接把消息返回，交给looper处理</p> <pre> <code class="language-java">else { mMessages = msg.next; msg.next = null; if (DEBUG) Log.v(TAG, "Returning message: " + msg); msg.markInUse(); return msg; }</code></pre> <p>如果整个队列中没有任何消息，就进入无限等待状态，</p> <pre> <code class="language-java">// 如果消息队列中没有任何就无限等待，直到下一个消息到来，并唤醒消息队列 nextPollTimeoutMillis = -1;</code></pre> <p>这里注意一点，所谓的等待是空闲等待，而不是忙等待。就是说如果应用程序注册了 IdleHandler 接口来处理一些事情，那么就会先执行这里 IdleHandler ，因为在执行的过程中可能有新的消息加入队列，所有需要重置等待时长为0，不在等待</p> <pre> <code class="language-java">if (pendingIdleHandlerCount <= 0) { // No idle handlers to run. Loop and wait some more. mBlocked = true; continue; } ....... pendingIdleHandlerCount = 0; nextPollTimeoutMillis = 0;</code></pre> <p>是不是有点头晕？这一段逻辑的确是消息机制中最复杂的，没明白的话可以多看一遍源码。把这一部分弄懂了，后面消息的发送和处理就比较简单了</p> <p><strong>消息发送</strong></p> <p>发送消息的函数有很多，但是最终都是调用的同一个函数</p> <pre> <code class="language-java">public final boolean sendMessageDelayed(Message msg, long delayMillis){ if (delayMillis < 0) { delayMillis = 0; } return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis); }</code></pre> <p>延时时间+当前时间组合成为这个消息的执行时间，然后调用 enqueueMessage</p> <pre> <code class="language-java">private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) { msg.target = this; if (mAsynchronous) { msg.setAsynchronous(true); } return queue.enqueueMessage(msg, uptimeMillis); }</code></pre> <p>这里把当前 Handler 赋值给 message的target 变量，还记得 looper.loop() 函数里面如果 MessageQueue.next() 返回了消息就交给 msg.target.dispatchMessage() 处理，这个 target 就是发送消息的 handler 。这就解释了为什么 handler 发送的消息一定会在 handler 中处理。</p> <p>之后，消息交给了MessageQueue的enqueueMessage()方法处理</p> <pre> <code class="language-java">boolean enqueueMessage(Message msg, long when) { synchronized (this) { ...... msg.markInUse(); msg.when = when; Message p = mMessages; boolean needWake; if (p == null || when == 0 || when < p.when) { //如果当前队列中没有任何消息，插入到消息队列的头部 msg.next = p; mMessages = msg; needWake = mBlocked; } else { //否则，遍历消息队列，根据消息的执行时间，从小到大的顺序插入到合适的位置 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; }</code></pre> <p>这个函数会根据消息的执行时间，从小到大的顺序把消息插入到消息队列中。如果消息队列处于等待状态的，还需要唤醒消息队列。唤醒的函数 nativeWake(mPtr); 是一个JNI方法，我们后续再说。现在只要知道唤醒后，消息队列又开始循环检查消息就行了。</p> <p><strong>消息执行</strong></p> <p>通过上面我们知道了</p> <ul> <li>handler发送消息</li> <li>Message.next()不断检测消息</li> <li>检测到消息后返回给looper.loop()</li> <li>交给msg.target.dispatchMessage()处理消息</li> </ul> <p>我们也知道了这个target就是发送消息的那个handler，再来看看它是怎么处理消息的</p> <pre> <code class="language-java">public void dispatchMessage(Message msg) { if (msg.callback != null) { handleCallback(msg); } else { if (mCallback != null) { if (mCallback.handleMessage(msg)) { return; } } handleMessage(msg); } }</code></pre> <p>这个函数就很简单了，如果构造 handler 的时候有 callback 就执行callback，否则就执行 handleMessage() ，执行我们自己的逻辑。</p> <p>好了，我们已经分析完 Handler、Looper、MessageQueue 的创建和它们在消息机制中扮演的角色，认真阅读这篇文章，我相信你会对android的消息机制有一个比较全面的认识。下面我们看看关于消息机制一些比较有意思的问题</p> <p><strong>既然 Looper.loop()会阻塞主线程，那为什么不会导致ANR？</strong></p> <p>这个问题可以通过2个方面来说</p> <p>1.主线程一定也必须要阻塞。android主线程是伴随着程序的开启就启动，退出才结束的。而不管是进程还是线程，对于Linux系统来说都是一段可执行的代码，如果不阻塞，主线程代码执行完毕就结束了，那我们的程序就可能用着用着就退出了。所以android主线程一定是阻塞的。</p> <p>2.至于为什么不会ANR。先看看会导致ANR的情况</p> <p>造成ANR的原因一般有两种：</p> <p>1.当前的事件没有机会得到处理（即主线程正在处理前一个事件，没有及时的完成或者looper被某种原因阻塞住了）</p> <p>2.当前的事件正在处理，但没有及时完成</p> <p>开篇我们说过android系统是基于消息驱动的，不管是点击一个按钮需要获得反馈还是activity生命周期，其实都是通过发送一个消息交给对应handler处理的。所以，主线程阻塞（ <strong>其实是消息队列进入等待状态</strong> ），说明没有任何事件（触摸，点击，生命周期切换）发生，没有消息需要处理，当然不会ANR</p> <p>当消息队列没有消息了，Looper.loop()中的for()死循环会退出吗</p> <p>阅读这篇文章后，我们知道了，Looper.loop()是肯定不会退出的，不然下一条消息到来了怎么处理呢？没有消息，它就会阻塞在 Message.next() 里面的 nativePollOnce(ptr, nextPollTimeoutMillis); 本地方法里面，即 nextPollTimeoutMillis==-1</p> <p> </p> <p>来自：http://www.jianshu.com/p/ea71e5921d83</p> <p> </p>