Android 从源码分析Handler消息机制

说起Handler，就不得不提Looper以及Message。我们在使用Handler发送消息时，就是将Message发送到MessageQueue消息队列中，然后通过Looper.loop()方法对MessageQueue消息队列中的消息进行轮询，利用Handler.dispatchMessage(msg)对消息派发，最后复写handleMessage(msg)根据不同的消息进行不同操作。接下来我们开始在源码上进行分析。

Looper

首先对于Looper来说，主要的是Looper.prepare()以及Looper.loop()这两个方法，让我们先看一看Looper.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));
}

从这里我们可以看到，在prepare()方法了，创建了Looper对象并将其添加到了sThreadLocal对象里，关于sThreadLocal，它是一个ThreadLocal对象，可以在线程中储存变量。同时第二行对sThreadLocat.get()判断是否为空，以抛出异常的方式，避免再次创建Looper对象，这样就保证一个线程中最多只有一个Looper对象和一个MessageQueue消息队列，接下来我们看下Looper的构造函数。

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

在Looper构造函数中，创建了MessageQueue（消息队列）。

所以，在Looper.prepare()函数中，主要是创建了Looper对象并储存到sThreadLocal里，在创建Looper的同时，创建了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;

// 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.isTagEnabled(traceTag)) {
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();
}
}

刚开始我们从myLooper()方法中获取到之前储存在sThreadLocal中的Looper对象，然后判断是否为空。从这里可以看出来，在调用Looper.loop()方法前，一定要先调用Looper.prepare()方法，否则会抛出异常。而我们的主线程，在程序启动的时候就已经调用了Looper.prepare()方法。

public static @Nullable Looper myLooper() {
return sThreadLocal.get();
}

继续往下看，可以知道在loop()方法中我们获取到了MessageQueue这个消息队列，然后通过无限循环对消息进行轮询，如果有消息则取出消息，通过msg.target.dispatchMessage(msg)对消息进行处理，而从Message源码得知msg.target就是Handler这个对象。

所以，从loop()方法中我们获取了储存在sThreadLocal的Looper对象，然后通过它得到MessageQueue消息队列，接下来从MessageQueue中取出消息，如果不为空，则通过msg.target.dispatchMessage(msg)进行处理，最后通过 msg.recycleUnchecked()对消息进行回收。

handler

我们先看下handler的构造函数，看看会有什么发现。

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

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.myLooper()这个方法获取到储存在sThreadLocal中的Looper对象，myLooper()方法上面有源码，就不在说了，我们获取到Looper对象后就可以得到Looper中的MessageQueue消息队列，然后Handler通过MessageQueue与Looper对象产生了联系。

所以在Handler构造函数中，主要做了得到Looper对象，然后通过Looper获取MessageQueue消息队列。

既然得到了MessageQueue，我们是不是应该往里面放消息了？接下来我们看下常用的sendMessage(msg)这个方法。

public final boolean sendMessage(Message msg){

a4b7
return sendMessageDelayed(msg, 0);
}

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) {
msg.target = this;
if (mAsynchronous) {
msg.setAsynchronous(true);
}
return queue.enqueueMessage(msg, uptimeMillis);
}

最后通过enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis)方法将我们的要发送的消息放到消息队列中。在这个方法里，我们看到了msg.target = this，是不是很眼熟呢，我们在上面Looper.loop()方法中可以看到，每次取出msg都会交给msg.target.dispatchMessage(msg)去处理。然后我们看下dispatchMessage(msg)里做了什么。

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时，对消息进行处理一定要复写handleMessage(Message msg)这个方法，根据msg.what进行不同操作。

至此，整个流程已经分析完了，最后我们来做个总结。

Looper

在Looper中，我们主要进行了两个操作

Looper.prepare():

在prepare()中，我们创建了Looper对象，并且在Looper构造函数中创建了MessageQueue这个消息队列，同时将Looper对象储存到sThreadLocal中。值得注意的是，当Looper与线程绑定时，只能存在一个Looper对象，一个MessageQueue队列。

Looper.loop():

在loop()中，首先获取到储存在sThreadLocal中的Looper对象，然后通过Looper对象得到MessageQueue消息队列。接着对消息队列进行无限循环取出每一个Message对象，如果不为空则利用msg.target.dispatchMessage(msg)对消息进行处理。

Handler

在Handler中，首先当我们初始化Handler时，通过myLooper()这个方法获取到Looper对象，从而得到MessageQueue消息队列。然后开始进行发送消息以及处理消息这两个过程。

发送消息：

我们从sendMessage(msg)一步一步观察得知，最后通过enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis)方法将Message放入到MessageQueue中。这是发送消息的过程。

处理消息：

我们知道在Looper.loop()开始对MessageQueue消息队列进行无限循环取出消息，然后通过msg.target.dispatchMessage(msg)对消息进行处理，最后再复写handleMessage(msg)对获取到的消息进行不同操作。这是处理消息的过程。

参考博文:

http://blog.csdn.net/lmj623565791/article/details/38377229/