Handler的消息传递机制详解

最近公司在招Android开发，同事负责面试，应聘的人简历上写了自己熟练掌握Handler的机制，于是同事问他Handler是怎么接收到它自己发送的消息的，他回答不上来。于是同事就没兴趣问下去了，面试完之后同事跟我说起这个事，我才意识到原来我也是停留在会用Handler的地步。以前一直不喜欢看源码，今天带着这个问题，我终于静下心来看了一下Handler的源码，发现Handler的源码还是挺简单的，于是在这记录下自己对Handler的理解，可能理解的不到位，欢迎各位指正。

一、为什么要用到Handler？

既然你诚心诚意地请教了，那我就大发慈悲地告诉你，为了宇宙的和平，为了防止世界被破坏……对不起，扯远了，言归正传。Android规定只有UI线程可以更新UI，子线程是不能更新UI的。通常耗时的操作我们都是放到子线程里面去执行的，当耗时操作执行完获取到结果后，如果这时我们要更新UI，由于是在子线程里，我们当然不然直接在子线程里更新UI,这个时候我们就要用到Handler了，实际上，Android里面所有更新UI的操作都是通过Handler来完成的。

二、Handler是如何更新UI的？

这个问题说来话长，估计得从猴子变人说起。大家都是做Android的，应该学过一点Java。Java的程序入口大家应该都知道，就是main()函数。Android也一样，它的程序入口也是main()函数，在ActivityThread这个类里面，我们点开它的源码就能找到。如下所示

public static void main(String[] args) {
  ……
  Looper.prepareMainLooper();
  ……
  Looper.loop();
  throw new RuntimeException("Main thread loop unexpectedly exited");
  ……
}

通过查看Looper的源码,我们可以发现prepareMainLooper()的作用是帮我们生成了一个Looper对象和一个MessageQueue对象，并且一个线程只有一个Looper,而一个Looper只有一个MessageQueue。原来系统已经默默地为主线程创建了一个Looper对象和一个MessageQueue对象，而更新UI操作必须要用到Looper和MessageQueue，所以我们可以直接在主线程里面更新UI。而子线程里面默认是没有Looper对象和MessageQueue对象的，所以在子线程里是不能直接更新UI的。注意我说的“直接”二字（重要的事说三遍），有些人可能会觉得奇怪，心想我明明可以在子线程里更新UI啊，比如像这样：

Handler handler = new Handler();
……
new Thread(new Runnable() {
  @Override
  public void run() {
    handler.post(new Runnable(){
      @Override
      public void run() {
         //更新UI;
      }
    });
  }
}).start();

好吧，你赢了。但是请注意我说的“直接”，你这不是直接更新UI好吧。如果你坚持这样认为，那我们就来研究一下为什么这样子就可以在子线程里面更新UI了呢？关键就在于你是在子线程外面new了一个Handler,因为在主线程new Handler()的同时，也new出来了一个Looper对象和一个MessageQueue对象。如果你在子线程里面new一个Handler(),比如像下面这样：

new Thread(new Runnable() {
  @Override
  public void run() {
    new Handler().post(new Runnable(){
      @Override
      public void run() {
        //更新UI;
      }
   });
  }
}).start();

你会发现程序报错了，提示如下错误：
java.lang.RuntimeException: Can't create handler inside thread that has not called Looper.prepare()
为什么会报这个错呢，我们来看下Handler的源码：

public Handler() {
  this(null, false);
}
……
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;
  ……
}

我们new Handler()的时候调用的是上面的那个构造函数，上面的构造函数里面又调用了下面的那个构造函数。也就是说Looper对象mLooper为null，为什么mLooper 为null呢？因为子线程里面默认是没有Looper对象的。
接下来我们再来探讨为什么有了一个Looper对象和一个MessageQueue对象就可以更新UI呢？

Looper是什么？

我们姑且把它称作轮询器，顾名思义，它的作用就是一直在那不停地轮询，还记得上面main()函数里面的Looper.loop()方法吗，这个方法就是轮询。轮询什么呢？轮询MessageQueue里面有没有Message，也就是我们所说的消息。Looper.loop()方法里面有一个死循环，除非程序退出，否则永远不会结束，这就是为什么我们的程序可以一直执行，而不是执行完main()方法后立马退出程序。

MessageQueue是什么？

我们姑且把它称作消息队列，它是用来存放Message的，我们经常会调用Handler的sendMessage(Message msg)方法；这个方法是干什么用的呢？这个方法就是用来把Message加入到MessageQueue当中，来供Looper进行轮询的。

Handler、Looper和MessageQueue到底有什么关系？

此三子者，缺一不可。如果我们想在子线程执行完后用Handler来更新UI,我们通常会先在主线程里面new一个Handler的对象，通过上面Handler的源码，我们可以发现，系统同时为我们创建了一个Looper对象和一个MessageQueue对象；然后我们会调用Handler的post(Runnable r)或者sendMessage(Message msg)来发送一个消息；其中Runnable r最终也会被转化成一个Message，这个Message会被加入到MessageQueue中。Looper调用loop()方法对MessageQueue进行轮询，我们来看下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;
        ……
        for (;;) {
            Message msg = queue.next(); // might block
            if (msg == null) {
                // No message indicates that the message queue is quitting.
                return;
            }
                msg.target.dispatchMessage(msg);
           ……
        }
    }

可以看到，里面有一个死循环，通过MessageQueue的next()方法去取出一个msg(Message)，如果msg为null,则线程阻塞，让出cpu资源。如果msg不为null,则调用msg.target.dispatchMessage(msg)对msg进行接收并处理。这个msg.target是什么东西呢？我们在Message类的源码里面可以发现，它竟然是一个Handler对象，那这个Handler对象会不会是我们之前new出来的那个Handler对象呢？答案是的。那它是什么时候被赋值的呢？就是在我们调用Handler的post(Runnable r)或者sendMessage(Message msg)的时候被赋值的，因为这两个方法最终都会进入Handler的enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis)方法里面：

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

可以看出，我们一开始new出来的Handler被封装进了Message中加入到MessageQueue中，这也解释了开篇提出的问题：Handler是怎么接收到它自己发送的消息的？原来它在发送消息的时候把自己封装进了消息中，加入到MessageQueue中，Looper.loop()轮询MessageQueue的时候，如果轮询到这个消息，它就自己出来接收并处理这个消息，也就是调用dispatchMessage(Message msg)方法。最后我们再来看一下这个方法：

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

如果我们一开始调用的是Handler的post(Runnable r)方法，这里执行的是 handleCallback(msg)方法，这个方法最后执行的是Runnable的run()方法，run()方法就是我们要执行的更新UI操作；如果我们一开始调用的是Handler的sendMessage(Message msg)方法,这里执行的就是handleMessage(msg)方法，这个方法相信大家都不会陌生，没错，我们更新UI的操作就是在这个方法里执行的。
说了这么多，相信你跟我一样，还是一头雾水，那我就根据我的理解再总结一下吧：如果子线程执行完后要更新UI，首先要通过主线程的Handler向主线程发送Message（消息），这个Message会被加入到MessageQueue中，然后Looper通过调用loop()方法不断轮询MessageQueue，如果有Message，那么Handler就会接收到这个Message并进行更新UI的操作。