android消息机制:Looper,Handler,Message

首先看下面问题：

1、我们在写代码的时候，不能在非UI线程更新UI界面，所以我们经常会使用Handler来发送一个消息，然后再由Hander来更新UI界面。问题来了：为何Hander能更新UI？

我们可以在android消息机制里面找到这两个问题的答案。

android消息机制主要用到三个类：Looper,Handler,Message.

一、Looper

Looper是用来给线程添加消息循环的，通常线程是没有消息循环的。通过在线程中调用Looper.prepare来初始化消息循环，然后调用Looper.loop方法来处理所有的消息。

如下代码（摘自android API）：

<pre name="code" class="java">class LooperThread extends Thread {
public Handler mHandler;

public void run() {
Looper.prepare();

mHandler = new Handler() {
public void handleMessage(Message msg) {
// process incoming messages here
}
};

Looper.loop();
}
}

简单几行代码，线程就拥有消息循环了。它的工作原理是什么呢？让我们来看以下prepare和loop的代码。

<pre name="code" class="java">    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));
}

   private Looper(boolean quitAllowed) {
       <span style="background-color: rgb(255, 255, 102);"> mQueue = new MessageQueue(quitAllowed);
        mThread = Thread.currentThread();</span>
    }

看高亮背景的两行代码，prepare主要做的事情是，创建一个消息队列,获取当前线程。

初始化完成后，接下来是循环提取消息，并处理消息。这是loop的工作。看一下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 (;;) {
<span style="background-color: rgb(255, 255, 102);"> Message msg = queue.next(); // might block</span>
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);
}

<span style="background-color: rgb(255, 255, 102);">msg.target.dispatchMessage(msg);</span>

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主要做的事情，就是从消息队列里取出消息，然后再丢给Handler去处理。

如果消息队列为空，线程会堵塞，等待下一个消息的到来。

最重要的是消息如何处理，msg.target.dispatchMessage(msg)，我们看看这段代码：

<pre name="code" class="java">    public void dispatchMessage(Message msg) {
if (msg.callback != null) {
<span style="background-color: rgb(255, 255, 102);">handleCallback(msg);</span>
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
<span style="background-color: rgb(255, 255, 102);"> handleMessage(msg);</span>
}
}

    private static void handleCallback(Message message) {
        message.callback.run();
    }

当你用Hander.post(runnable)的时候，就会执行handleCallback(msg)。当你重载Handler的handerMessage(msg)，调用Handler.sendEmptyMessage等方法的时候，就会在你重载的handlerMessage里处理。

至此，Looper的工作就完成了。简单来说，Looper就是给线程增加了一个消息队列。

接下来的问题是，如何和Hander交互。

二、Handler

Hander 用来往线程的消息队列里发送消息或Runnable。当你在线程中创建一个Hander对象后，这个Hander对象就和这个线程的消息队列关联在一起了。Handler发送的消息都会送到其关系的线程消息队列中去。

Handler有两个功能：1、在指定时间发送一个消息或Runnable。2、跨进程执行，即你可以在另一个线程里，使用Handler发送消息或Runnable, 这个消息会在Hander关联的线程里执行。

比如说，我们启动一个Acticity的时候，就会执行一个主线程（UI线程）。如果你开启一个新线程去做别的事情，比如说下载网络图片。在图片下载完成后，需要把图片设置到ImageView里面。如果直接在你下载的线程里面更新UI，就会出错。这时候，就需要用一个UI线程的Handler来刷新UI。

ok。到源码时间了。看看Handler的构造函数，就知道Handler是如何关联线程的。

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

<span style="background-color: rgb(255, 255, 102);">mLooper = Looper.myLooper();</span>
if (mLooper == null) {
throw new RuntimeException(
"Can't create handler inside thread that has not called Looper.prepare()");
}
<span style="background-color: rgb(255, 255, 102);"> mQueue = mLooper.mQueue;
mCallback = callback;</span>
mAsynchronous = async;
}

Looper.myLooper()就返回当前线程的Looper，mLooper.mQueue就是Looper的消息队列。

再来看以下，Hanlder发送消息的时候，做了什么事情：

<pre name="code" class="java">   public final boolean sendEmptyMessage(int what)
{
return sendEmptyMessageDelayed(what, 0);
}

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

    public final boolean sendMessageDelayed(Message msg, long delayMillis)
    {
        if (delayMillis < 0) {
            delayMillis = 0;
        }
        return 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);
    }

    private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
        <span style="background-color: rgb(255, 255, 102);">msg.target = this;</span>
        if (mAsynchronous) {
            msg.setAsynchronous(true);
        }
        return <span style="background-color: rgb(255, 255, 102);">queue.enqueueMessage(msg, uptimeMillis);</span>
    }

所以，不管调用哪种send message的方法，最终都是调用到enqueueMessage的方法里。

看里面高亮的两行代码：msg.targer = this， 把Hander赋给了Message。这就是我们在loop方法里看到的，msg.target.dispatchMessage(msg)，消息会交给Handler处理。

queue.enqueueMessage把消息放到了线程的消息队列里。

Handler还有一个方法，post一个Runnable,最终也是转成发送消息到线程的消息队列。看以下源码：

<pre name="code" class="java">    public final boolean post(Runnable r)
{
return  <span style="background-color: rgb(255, 255, 102);">sendMessageDelayed(getPostMessage(r), 0);</span>
}

    private static Message getPostMessage(Runnable r) {
        Message m = Message.obtain();
        m.callback = r;
        return m;
    }

以上就是消息机制的基本流程了。

小结一下:如下图，主要的过程就是，Handler发送消息到Looper的MessageQueue, Looper线程分发消息给Handler执行