深入理解Android消息机制，从源码解析Handler,Looper，MessageQueue

Android 规定不允许在子线程中更新UI,但是为了保证UI线程（也即主线程）的流畅性，通常一些耗时操作都是在子线程中进行，比如，IO操作，网络请求操作等，这就涉及到一个问题，如果子线程这些操作执行完，想要更新界面的控件显示该怎么办，显然不能直接在子线程操作，否则会抛出异常；为了解决这个问题，Android设计了一套异步消息机制，这包括Handler,Looper,MessageQueue。

1.Handler解析
下面我们先从Handler的使用一步步深入解析，抽丝剥茧；

Handler handler = new Handler(){        @Override        public void handleMessage(Message msg) {           //更新UI操作    mButton.setText(“hello,world”);        }    };    @Override    protected void onCreate(Bundle savedInstanceState) {        super.onCreate(savedInstanceState);        setContentView(R.layout.activity_main);        new Thread(){            @Override            public void run() {                handler.sendEmptyMessage(123);            }        }.start();}

上面这段代码，相信大家也都很熟悉，通过调用handler.sendEmptyMessage(123);就从子线程切换到了UI线程，进而更新UI;那么这里面都发生了什么呢，我们接着看，点进sendEmptyMessage进去看一下，代码如下：

public final boolean sendEmptyMessage(int what)    {        return sendEmptyMessageDelayed(what, 0);}

再接着点击sendEmptyMessageDelayed方法，代码如下：

public final boolean sendEmptyMessageDelayed(int what, long delayMillis) {        Message msg = Message.obtain();        msg.what = what;        return sendMessageDelayed(msg, delayMillis);    }

我们看到这个方法，创建了一个Message对象，用的是Message.obtain()方法，那为什么他不直接new一个Message对象呢，点进obtain()方法，我们看到，代码如下:

/**     * Return a new Message instance from the global pool. Allows us to avoid allocating new objects in many cases.     */public static Message obtain() {        synchronized (sPoolSync) {            if (sPool != null) {                Message m = sPool;                sPool = m.next;                m.next = null;                m.flags = 0; // clear in-use flag                sPoolSize--;                return m;            }        }        return new Message();    }

从该方法的注释我们看到：这个方法从全局消息池里面取出一个Message对象给我们用，这样就避免再次创建Message对象，从而节省内存空间，当然如果消息池中没有message对象，他就会new一个新对象，这个就相当于的对象的复用。所以，我们创建Message的时候，最好也要用这种方法，而不是简单粗暴的new Message().
好，我们接着看sendEmptyMessageDelayed这个方法，这个方法创建好message对象之后，并给她的what字段赋值之后，调用了sendMessageDelayed(msg, delayMillis)方法，接着点进去看看，代码如下：

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

首先，获得一个MessageQueue对象，然后又调用了enqueueMessage(queue, msg, uptimeMillis)方法，接着点进去，

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,也就是我们的handler实例，然后调用queue.enqueueMessage(msg, uptimeMillis);将消息插入MessageQueue中，至此，handler的发送消息的工作终于结束，也即是顺利把消息投递到了MessageQueue中。

2.MessageQueue解析：

MessageQueue内部维护一个单链表，主要用来插入和读取Message操作（读取的同时伴随着删除）
首先我们看一下MessageQueue的enqueue方法：由于代码较长和复杂，我就不贴代码了，而且我们没有必要弄懂每一句代码，该方法的主要作用是将message插入到链表中，下面再看一下next（）方法，也即是读取message，同样代码也补贴了，该方法是一个死循环方法，如果MessaQueue中没有消息，会阻塞在那里，如果有新消息来的话，会返回该消息，并讲它从链表中删除。

3.Looper解析

Looper扮演者 消息循环的角色，简单来说就是它会不停轮询MessageQueue中是否有消息，如果有就立即处理，没有就阻塞在那里；那looper是怎么和MessageQueue关联起来的呢，我们先来看一下Looper的构造函数：

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

可以看到，MessageQueue对象正是Looper创建的，我们知道，Handler的工作需要Looper，没有looper的话，创建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为空，就会抛出异常；至此，有人要问了，我也没创建Looper对象啊，也能正常用handler啊，那是因为，在主线程中，Android已经帮我们创建好了，Android的入口程序是ActivityThread.java这个类，我们看一下他的主函数：

public static void main(String[] args) {    ….//省略部分代码53985399        Process.setArgV0("<pre-initialized>");54005401        Looper.prepareMainLooper();54025403        ActivityThread thread = new ActivityThread();5404        thread.attach(false);54055406        if (sMainThreadHandler == null) {5407            sMainThreadHandler = thread.getHandler();5408        }54095410        if (false) {5411            Looper.myLooper().setMessageLogging(new5412                    LogPrinter(Log.DEBUG, "ActivityThread"));5413        }54145415        // End of event ActivityThreadMain.5416        Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);5417        Looper.loop();54185419        throw new RuntimeException("Main thread loop unexpectedly exited");5420    }

可以看到，Looper.prepareMainLooper()；这句就已经创建了Looper，点进这个方法看看，我们看到，最终调用了prepare()这个方法，
我们看一下这个方法：

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

这个方法里面，通过ThreadLocal类型的变量来保存Looper实例，关于ThreadLocal，简单来说，就是，它会保存一个与当前线程相关的唯一一个对象，即每个线程里只创建一个Looper对象，关于他的介绍，我会再写一篇文章，现在我们就简单了解下。
Looper最关键的一个方法就是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            final Printer logging = me.mLogging;            if (logging != null) {                logging.println(">>>>> Dispatching to " + msg.target + " " +                        msg.callback + ": " + msg.what);            }            final long traceTag = me.mTraceTag;            if (traceTag != 0) {                Trace.traceBegin(traceTag, msg.target.getTraceName(msg));            }            try {                msg.target.dispatchMessage(msg);            } finally {                if (traceTag != 0) {                    Trace.traceEnd(traceTag);                }            }            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();        }    }

可以看到，loop也是一个死循环方法，里面不断调用messagequeue的next方法，来查看消息队列是否有消息，一旦有消息了，就会调用msg.target.dispatchMessage(msg);这句来出来消息，target就是我们的handler对象，下面我们再来看一下dispatchMessage(msg)这个方法：

public void dispatchMessage(Message msg) {        if (msg.callback != null) {            handleCallback(msg);        } else {            if (mCallback != null) {                if (mCallback.handleMessage(msg)) {                    return;                }            }            handleMessage(msg);        }    }

先看第一行，如果callback不为空，就调用handleCallback来出来，这个callback是一个Runnable类型的对象，当我们使用handler的post方法投递消息时，传递的就是一个Runnable类型的参数，看一下代码:

public final boolean post(Runnable r)    {       return  sendMessageDelayed(getPostMessage(r), 0);    }我们在看一下getPostMessage方法：private static Message getPostMessage(Runnable r) {        Message m = Message.obtain();        m.callback = r;        return m;    }

至此我们看到，这个runnable类型的对象赋值给了message的callback字段，然后返回一个Message对象，接着调用sendMessageDelayed把消息发出去了，很巧妙是不是。所以除了使用sendmessage发送消息之外，也可以使用post这种方式放松消息。接下来，我们接着看上面dispatchMessage这段代码，如果没有使用post这种方式，代码就会走到else里面，然后判断mCallback是否为空，mCallback是Callback类型，他是Handler的内部的一个接口，代码如下：

public interface Callback {        public boolean handleMessage(Message msg);    }

那么这个mCallback,在哪里赋值的呢，搜索一下看到，在Handler的另一个构造函数的参数里有这个类型，我们可以这样使用：

handler = new Handler(new Handler.Callback() {            @Override            public boolean handleMessage(Message msg) {                //do something                return false;            }        });

这样算是handler的另外一种创建方式吧；我们还是看上面dispatchMessage那段代码，如果mCallback不为空，就执行callbackd的handleMessage方法，如果为空，就执行handler的handleMessage方法；这里我们总结一下dispatchMessage方法，他的处理方式是：如果message的callback不为空，就执行callback的run方法，如果为空，再判断mCallback是否为空，不为空就执行mCallback的handleMessage，为空就执行handler本身的handleMessage方法；
优先级是：message.callback—>Handler.Callback—>Handler.handleMessage

至此，消息从发送到处理，我们就分析完了，也就从当初在子线程发送消息，过渡到到在UI线程处理消息，很巧妙是不是。(注意：不是说只能在子线程发送消息，主线程同意也可以。)
下面我们再来看一张图：这张图是一位大神画的，已经很好了，我就不再画了

这张图我再简单解释一下：首先handler把消息发送到MessagQueue的单链表中，然后Looper立刻就检测到有消息来了，然后调用msg.target.dispatchMessage()来让handler来处理消息，由于handler是在主线程创建的，所以也就是已经来到主线程来操作UI了。

至此，Android消息机制我们就分析完了，有不懂的或者有建议的欢迎留言，共同学习哈