Android中的Handler、Looper、Message、MessageQueue之间流程关系

Handler、Looper、Message、MessageQueue这四者的关系，用比较通俗的方式解释，可以理解为：Looper是传送带在不停的运送货物，MessageQueue是传送带上面的货物队列，Message就是货物队列中一个一个的货物，而Handler则是货物被消费的地方。

Looper的分析

Looper是整个消息机制的关键节点，Looper类用来为一个线程开启一个消息循环。主线程是默认开启的，但是新的线程是默认不开启的，所以我们使用Handler从主线程或其他线程往子线程发消息，是会抛出没有Looper对象这个错误，这里我们如果想往子线程发送消息，那么必须在子线程中调用Looper.prepar()启动Looper，然后再调用Looper.loop()让Looper开始工作。每个Looper都有与之对应的MessageQueue当执行Looper.loop后MessageQueue的消息就开始被处理了。这里需要注意的是，Looper.loop是一个循环，当有消息时处理消息，没有消息时挂起。所以Looper.loop之后的代码是无法运行的。如过需要运行之后的代码，需要执行当前线程的handler.getLooper.quit()使Looper退出消息处理，循环结束后面代码就可以运行了。

---

Looper和Handler、Message、MessageQueue的关系

要想了解Looper和Handler、Message、MessageQueue的关系我们最好能从源码的角度将发送消息到消息队列再到分发处理消息的整个流程重新走一边。

• 首先创建的是Looper我们这里看下Looper的构造方法：

    private Looper(boolean quitAllowed) {
        mQueue = new MessageQueue(quitAllowed);
        mThread = Thread.currentThread();
    }

这里可以看到当启动了Looper后会创建一个MessageQueue与之绑定，并且绑定当前线程。

有了Looper这个传送带和MessageQueue这个货物队列，我们再看看发送与收取货物的Handler的构造方法：
空参的构造函数执行了 this(null, false);所以也就是执行了Handler(Callback callback, boolean async)这个构造函数下面我们看这个构造函数

    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());
            }
        }

        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中的构造方法中上面那个if是打印内存泄漏的日志， Looper.myLooper()用来获取当前线程的Looper对象，如果没有则抛出错误，就是Looper分析中提到的没有Looper对象的问题，解决方法也在那段中说明了，下面再通过mLooper.mQueue获取当前线程的MessageQueue对象。下面我们有了Looper这个对象就可以以他为基础通过Handler进行通讯了。

Handler发送消息时可以设置不同的参数，设置延时发送等等很多种方法，但是最后都会走到这段代码：

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);
    }

从这段代码我们可以看到，msg被添加到由了构造函数传入的MessageQueue中，最后执行了enqueueMessage(queue, msg, uptimeMillis)方法进入MessageQueue队列 ：

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的明确就是this也就是本类，所以后面消息分发时也会分发到这个target就是本类。

现在消息已经传递到了Looper中，下面我们看看在Looper中消息是怎么分发的。
Looper中的消息分发的关键是loop()方法,下面看看这个方法的源码：

/**
     * Run the message queue in this thread. Be sure to call
     * {@link #quit()} to end the loop.
     */
    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;

        // 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 (;;) {
            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
            Printer logging = me.mLogging;
            if (logging != null) {
                logging.println(">>>>> Dispatching to " + msg.target + " " +
                        msg.callback + ": " + msg.what);
            }

            msg.target.dispatchMessage(msg);

            if (logging != null) {
                logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);
            }

            // Make sure that during the course of dispatching the
            // identity of the thread wasn't corrupted.
            final long newIdent = Binder.clearCallingIdentity();
            if (ident != newIdent) {
                Log.wtf(TAG, "Thread identity changed from 0x"
                        + Long.toHexString(ident) + " to 0x"
                        + Long.toHexString(newIdent) + " while dispatching to "
                        + msg.target.getClass().getName() + " "
                        + msg.callback + " what=" + msg.what);
            }

            msg.recycleUnchecked();
        }
    }

从上面代码中可以明显看到几个关键方法

1. queue.next()：在死循环中，不断的通过queue.next获取消息，
2. msg.target.dispatchMessage(msg) ：注意这里的target就是上面我们分析的那个target即发送消息的那个Handler对象,这里将消息队列中的消息进行了分发。
3. msg.recycleUnchecked()：这个方法是当消息被分发掉，对消息进行正在使用的标记。

消息已经分发完了，下面又回到了，Hanlder中处理消息了，那么我们常用的handler.handleMessage(msg)方法又是什么时候调用的呢，在上面那段的第2个关键方法msg.target.dispatchMessage(msg) 这个方法其实就是调用了target中的dispatchMessage()方法，这个target就是handler，所以我么再回到Handler的源码中，看看这个dispatchMessage()是怎么接收消息的：

 /**
     * 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);
        }
    }

从这段代码中，可以明确的看到执行了handleMessage(msg)这个方法，到此整个消息发送到接收的流程已经全部结束了。

---

总结

通过以上的分析可以知道 Looper.loop()不断地获取MessageQueue中的Message，然后调用与Message绑定的Handler对象的dispatchMessage方法，最后handleMessage就在dispatchMessage方法里被调用了。从这些源码中可以看到，不同的handler对象可以设置不同的target消息也会分发到不同的handleMessage方法中，所以可以得出结论，Looper可以有多个handler与之绑定并向他发送消息，但是只能有一个对应的线程，同时也只能有一个MessageQueue。

转载于:https://www.jianshu.com/p/6e7ad58bc511