【Android消息机制】简要分析（一）

主要组成概述：Hanlder、MessageQueue以及Looper

1.Handler：线程切换

2.MessageQueue：用来存储信息 内部实现是单链表而不是队列。

3.Looper：无限循环的方式去查找是否有消息

备注：Looper中一个ThreadLocal的概念
作用：是来存储每一个线程中数据。
用途：Hanlder创建的时候会采用当前线程的Looper来构造消息循环系统，Handler正式通过ThreadLocal来获取当前的线程Looper的。

源代码

1.Handler是如何将三者联系起来的？

看看Handler创建源代码：

public Handler(Callback callback, boolean async) {
        ...//省略
        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;
    }

到调用了Looper.myLooper()

我们点进看看：

   /**
     * Return the Looper object associated with the current thread.  Returns
     * null if the calling thread is not associated with a Looper.
     */
    public static Looper myLooper() {
        return sThreadLocal.get();
    }

没错，的确是这样印证了Handler、Looper的关系。

那么MessageQueue是如何一起协同工作呢？

我们看到mQueue = mLooper.mQueue;

所以从不难推断出MessageQueue在Looper初始化的时候也一并初始化了。

从这里我们也可以看出：无论我们在主线程创建多少个Handler，他们公用一个消息队列的

2.Looper是如何工作的？

上面概述的时候我们知道，Looper是负责从消息队列中读取消息，然后回传到handler的handleMessage方法来处理消息的。

大家不知道还记不记得，我们是如何在子线程创建一个Handler的？ 我们需要调用Looper.prepare()来准备一个Looper，并且调用Looper.loop()。

很明显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;

        ...

        for (;;) {
            Message msg = queue.next(); // might block
            if (msg == null) {
                // No message indicates that the message queue is quitting.
                return;
            }

           ...

            msg.target.dispatchMessage(msg);

            ...


        }
    }

    /**
     * Return the Looper object associated with the current thread.  Returns
     * null if the calling thread is not associated with a Looper.
     */
    public static Looper myLooper() {
        return sThreadLocal.get();
    }

第一步：先调用了Looper.myLooper()这个方法，返回当前线程所在的Looper实例。备注：这里也刚好可以看到了ThreadLocal的用途了。

第二步：无限死循环 如果有消息来了就：msg.target.dispatchMessage(msg);

这个msg.target是什么呢？ 通过Message源代码发现 就是发送这个msg对象的Handler实例： Handler target;

那msg是什么时候保存的呢？通过Handler源代码发现：

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

msg在入队前，保存了这个handler实例的引用。

然后调用了这个Hanlder实例的dispatchMessage的方法。

那我们来看看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);
实际上他是一个空方法：

    public void handleMessage(Message msg) {
    }

这个就是为什么我们创建Handler之后要重写这个方法来处理消息了。

-Hans 2016.2.25 23:45