Android handler机制浅析

在安卓中，Handler负责消息的传递，它提供了一套在线程间传递消息的机制。Handler与looper、message、messageQueue一起，共同构成了安卓的消息发送框架。初学安卓的朋友可能对安卓的线程模型感到困惑，也会感到有很多限制，UI线程既不能等待，又不能做耗时操作，非UI线程可以做耗时操作，却不能改变UI。但这些问题却可以通过handler——线程间的消息传递来解决。那么handler内部是怎么实现的呢？它的实现原理是什么？让我们一起来探个究竟。

下面是Handler的一个基础用法。我们首先在主线程里定义了一个Handler，然后新启动一个线程，在该线程里通过该handler的post方法可以向主线程发送消息。在post方法下的runnable会运行在主线程中，这样就实现了“在非UI线程更新UI”的操作。

   private Handler mHandler;    @Override    protected void onCreate(Bundle savedInstanceState) {        super.onCreate(savedInstanceState);        mHandler = new Handler();        new Thread(new Runnable() {            @Override            public void run() {                mHandler.post(new Runnable() {                    @Override                    public void run() {                        //在这里可以更新UI                        ...                    }                });            }        }).start();    }

在讲Handler机制之前，我们首先需要讲一下与handler有关的几个类：ThreadLocal、MessageQueue、Message和Looper。ThreadLocal的作用为提供一个只与单个线程有关的变量，在我的博客ThreadLocal源码浅析一文中对ThreadLocal进行了详细讲解，有兴趣的朋友可以看看。MessageQueue则是一个消息队列，以队列的形式存储着handler发送的消息（Message）。而Looper则是消息机制的核心类，它封装了ThreadLocal，MessageQueue，负责从消息队列中轮询、获取消息并发送等核心操作。它的两个核心方法prepare()和loop()方法也是本篇博客的重点。下面我们来看一下Looper是怎么实现的。

首先来看下Looper类的几个重要属性：

public final class Looper {    private static final String TAG = "Looper";    // sThreadLocal.get() will return null unless you've called prepare().    static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();    private static Looper sMainLooper;  // guarded by Looper.class    final MessageQueue mQueue;    final Thread mThread;    private Printer mLogging;    ...}

Looper定义了几个比较重要的属性：
sThreadLocal
sMainLooper
mQueue
sThreadLocal用于存储每个线程的looper，即使得每一个线程都有一份自己的looper（如果设置的话），sMainLooper则为主线程的looper，mQueue则为Looper所包含的消息队列。要注意的是，sThreadLocal和sMainLooper都被设为static的，即在一个进程中，系统只存在一个mainLooper，sThreadLocal也被各个线程共享，只不过每个线程在sThreadLocal中取到的值不同（见ThreadLocal源码浅析）。

Looper还有两个非常重要方法：prepare()和loop()。先来看下prepare()方法：

    public static void prepare() {        prepare(true);    }    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));    }

可以看到，当一个线程调用了Looper.prepare()方法时，会将一个Looper的新实例放入threadLocal中，也就是说，当前线程和一个Looper绑定了，我们可以理解为该线程变成了“looper线程”，这个线程拥有了自己单独的looper实例，也就意味着拥有了单独的messageQueue、Printer等。此外，一个线程只能绑定一次Looper，再次绑定会抛出RuntimeException异常。

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

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

Loop方法也比较清晰：首先，loop方法会调用myLooper()方法从ThreadLocal里返回当前线程所绑定的Looper，接着，得到这个Looper的MessageQueue，然后，loop()方法会定义一个无限循环，不断地从这个MessageQueue里获取消息（ Message msg = queue.next(); ），并发送给对应的handler（msg.target.dispatchMessage(msg);）。所以，我们在使用Looper的时候，首先要调用它的prepare()方法，将当前线程变成“looper线程”，再调用looper.loop()方法循环获取消息。
举个小例子：

    new Thread("lzq thread") {            @Override            public void run() {                Looper.prepare();//将本线程变为Looper线程                Handler myHandler = new Handler() {                    @Override                    public void handleMessage(Message msg) {                        Log.v("lzq", Thread.currentThread().getName());                    }                };                myHandler.sendEmptyMessage(0);                Looper.loop();//由于是无限循环，要在线程最后调用            }        }.start();

可以看到，打印出的消息为lzq thread，证明handler运行在了子线程。幸运的是，在安卓的主线程中已经为我们做好了这些事情，在操作主线程的时候我们只要调用handler发送和接收消息就可以了。

我们再来看看Handler是怎样向MessageQueue里push消息的。首先看下Handler的构造方法：
Handler的构造方法很多，这里例举出两个：

 public Handler(boolean async) {        this(null, async);    }

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

上面的构造方法会调用下面这个。通过第二个构造方法可以看到，Handler内部包含了Looper的实例mLooper，和MessageQueue mQueue。在默认情况下，mLooper被实例化成当前线程绑定的looper，而mQueue则为该looper内部的MessageQueue。当我们采用handler调用sendMessage或post的时候：

    public final boolean sendMessage(Message msg)    {        return sendMessageDelayed(msg, 0);    }

sendMessage和post方法都会调用一系列的方法，但最终会转到这个方法：

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

通过enqueueMessage方法，待发送的Message会被放入到handler对应的looper的MessageQueue中，进而等待执行了。

我们再回过头来看最开始的例子，handler定义在主线程中，也就是说，该handler关联了主线程的looper，这样的话，当其它线程调用这个handler的post()或sendMessage()方法时，本质上是将message放入主线程looper的messageQueue中，再适时进行执行，这样就实现了“在非UI线程更新UI”的操作。因为本质上还是通过主线程更新UI，所以在该handler中不能做耗时的操作。

总结：
Handler与looper、message、messageQueue一起，共同构成了安卓的消息发送框架。先从looper说起，looper有两个核心方法：prepare()和loop()。prepare方法会将一个looper实例放在当前线程的threadlocal中，并使looper维护一个唯一的MessageQueue，使当前线程变成looper线程，loop方法则是构建一个无线循环，循环遍历messageQueue，将messageQueue中的message取出并发送，最后会调用对应handler的handleMessage方法处理。总之，looper负责绑定线程，循环处理消息。而handler负责接收并传递消息。handler内部需要绑定一个looper。我们要做的就是调用handler.sendmessage方法，他会将message发送给handler对应的looper下面的Messagequeue中，再通过looper.loop方法进行调用处理。我们再调用handler.handleMessage接收。这样就实现了线程间的通信。