一、概述
在Android消息机制浅析——基本使用一文中，我们对Android消息机制中的Handler和Message有了一个基本的了解，能够进行线程之间的通信。如果我们稍加注意，会注意到Hanlder的多个构造函数中会提到一个Looper的类。所以，在这次源码探究中，我们会涉及到Looper、Handler、Message、MessageQueue几个概念。
- Message：消息体对象，可用于存储我们要传送的数据。
- MessageQueue：消息体队列，用于管理Handler发送的Message对象。
- Looper：循环控制器，用于控制我们的消息管理，消息的取出与使用。
- Handler：消息的处理器，用于消息的发送与处理。
它们各司其职，就完成了Android整个消息的流通。
二、源码探究
1、Message对象
Message在整个Android的消息机制中充当着消息体的角色，它用于包装存储我们的数据在消息之间进行传递。如何创建一个Message对象呢？
/** Constructor (but the preferred way to get a Message is to call {@link #obtain() Message.obtain()}).
*/
public Message() {
}我们可以看到它有一个无参的构造函数，但是系统并不建议我们使用它的构造函数来创建Message对象，而是建议我们使用obtain()方法来创建Message对象，显然这个方法肯定是个静态方法。
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();
}先判断sPool这个Message对象是否为空，如果不为空，就将这个Message对象进行复用，同时对这个Message的标识信息进行初始化，去除标记，然后将sPoolSize减1.如果为null，则通过构造函数进行创建一个新对象。通过对比构造函数，我们发现通过obtain方法进行创建对象，提供了效率，减少了不必要的Message对象创建。
我们在Android消息机制浅析——基本使用中简单介绍了Message对象，我们知道它有许多成员变量用于帮助我们存储数据。我们从源码中简单的摘要出来。
public final class Message implements Parcelable {
/**
* 用户定义的区别标识
* with other handlers.
*/
public int what;
/**
* 用于存储一些简单的int值
*/
public int arg1;
public int arg2;
//存储Object对象
public Object obj;
//存储Bundle数据
Bundle data;
//存储Hanlder对象，与发送它的Hanlder进行绑定关系
Handler target;
//Message的标识，正在使用
static final int FLAG_IN_USE = 1 << 0;
static final int FLAG_ASYNCHRONOUS = 1 << 1;
static final int FLAGS_TO_CLEAR_ON_COPY_FROM = FLAG_IN_USE;
//Message的标识
int flags；
//有时为了保存一些信息，用于设置next
Message next；
//存储Runnable
Runnable callback;
.....
}在源码中我们同样可以发现obtain()方法的几个重载函数。
- public static Message obtain(Message orig)
- public static Message obtain(Handler h)
- public static Message obtain(Handler h, Runnable callback)
- public static Message obtain(Handler h, int what)
- public static Message obtain(Handler h, int what, int arg1, int arg2)
- public static Message obtain(Handler h, int what,
int arg1, int arg2, Object obj)
在这几个重载函数中，我们可以在obtain函数进行一些变量的初始化，完成Message的创建。我们从中摘取public static Message obtain(Handler h, int what,
int arg1, int arg2, Object obj) 给大家示例。
public static Message obtain(Handler h, int what,
int arg1, int arg2, Object obj) {
Message m = obtain();
m.target = h;
m.what = what;
m.arg1 = arg1;
m.arg2 = arg2;
m.obj = obj;
return m;
}在这个构造方法中，我们要着重注意一点：Message与Hanlder的绑定，Message通过target存储handler就行关系的绑定。
当一个消息体完成它的使命后，它就该被销毁回收，所以这里Message通过recycle()方法用于销毁Message对象。
public void recycle() {
if (isInUse()) {
if (gCheckRecycle) {
throw new IllegalStateException("This message cannot be recycled because it "
+ "is still in use.");
}
return;
}
recycleUnchecked();
}在Message进行回收的时候，首先判断该Message对象是否正在使用，如果正在使用，判断gCheckRecycle变量是否为真如果为true，则抛出异常并返回，为false则直接返回。补充下gCheckRecycle这个成员变量。
private static boolean gCheckRecycle = true;这个对象初始值为true，通过方法updateCheckRecycle进行更改：
public static void updateCheckRecycle(int targetSdkVersion) {
if (targetSdkVersion < Build.VERSION_CODES.LOLLIPOP) {
gCheckRecycle = false;
}
}如果系统版本小于21，则为false。（深入原因估计是系统源码又改了）。
当一个Message不处于正在使用的时候，系统通过recycleUnchecked()方法进行回收。
/**
* Recycles a Message that may be in-use.
* Used internally by the MessageQueue and Looper when disposing of queued Messages.
*/
void recycleUnchecked() {
// Mark the message as in use while it remains in the recycled object pool.
// Clear out all other details.
flags = FLAG_IN_USE;
what = 0;
arg1 = 0;
arg2 = 0;
obj = null;
replyTo = null;
sendingUid = -1;
when = 0;
target = null;
callback = null;
data = null;
synchronized (sPoolSync) {
if (sPoolSize < MAX_POOL_SIZE) {
next = sPool;
sPool = this;
sPoolSize++;
}
}
}回收所做的工作就是清除一个Message对象的细节属性，置空初始化。
小结：
Message作为消息体在消息机制中存在，系统建议我们使用Message.obtain()方法进行创建一个Message对象，目的是为了提高使用率。同时对于一个正在使用中的Message对象是无法进行回收的，系统报出异常“This message cannot be recycled because it is still in use.”
2、MessageQueue对象
消息队列，在消息机制中充当仓库的作用，用于存储Message对象。它持有的Message对象通过Looper进行分发，同时Message对象不是直接通过MessageQueue对象的方法进行添加，而是通过Handler进行添加。
既然作为一个消息体的“仓库”，我们只重点关心它的添加、删除、遍历即可。
- boolean enqueueMessage(Message msg, long when)：添加Message
- void removeMessages()：删除指定的message
- Message next()：遍历Message对象
（1）、boolean enqueueMessage(Message msg, long when)
用于添加我们的Message。
boolean enqueueMessage(Message msg, long when) {
if (msg.target == null) {
throw new IllegalArgumentException("Message must have a target.");
}
if (msg.isInUse()) {
throw new IllegalStateException(msg + " This message is already in use.");
}
synchronized (this) {
if (mQuitting) {
IllegalStateException e = new IllegalStateException(
msg.target + " sending message to a Handler on a dead thread");
Log.w("MessageQueue", e.getMessage(), e);
msg.recycle();
return false;
}
msg.markInUse();
msg.when = when;
Message p = mMessages;
boolean needWake;
if (p == null || when == 0 || when < p.when) {
// New head, wake up the event queue if blocked.
msg.next = p;
mMessages = msg;
needWake = mBlocked;
} else {
// Inserted within the middle of the queue. Usually we don't have to wake
// up the event queue unless there is a barrier at the head of the queue
// and the message is the earliest asynchronous message in the queue.
needWake = mBlocked && p.target == null && msg.isAsynchronous();
Message prev;
for (;;) {
prev = p;
p = p.next;
if (p == null || when < p.when) {
break;
}
if (needWake && p.isAsynchronous()) {
needWake = false;
}
}
msg.next = p; // invariant: p == prev.next
prev.next = msg;
}
// We can assume mPtr != 0 because mQuitting is false.
if (needWake) {
nativeWake(mPtr);
}
}
return true;
}enqueueMessage的整体流程：
首先判断Message对象的target是否为null（所附属的Handler，说白了就是发送源是否为null），如果为null，抛出异常“Message must have a target”。接着判断该Message是否正在使用，如果是，抛出异常“ This message is already in use.”。当上面条件不符合，则该Message是合法的，才开始添加到MessageQueue中。接着判断mQuitting是否为true，如果为true，抛出异常“sending message to a Handler on a dead thread”，说明依附的Hanlder所在的线程已死。所有的检查都不符合，则开始进行添加，首先通过markInUse()方法设置Message的flags |= FLAG_IN_USE;接着设置when参数，最后插入到链表中。下面我们就开始分析这个Message的插入流程顺序：
（2）、void removeMessages()
用于删除我们指定的Message。它有两个重载函数：
- void removeMessages(Handler h, int what, Object object)
- void removeMessages(Handler h, Runnable r, Object object)
原理都相同，挑一个研究下。
void removeMessages(Handler h, int what, Object object) {
if (h == null) {
return;
}
synchronized (this) {
Message p = mMessages;
// Remove all messages at front.
while (p != null && p.target == h && p.what == what
&& (object == null || p.obj == object)) {
Message n = p.next;
mMessages = n;
p.recycleUnchecked();
p = n;
}
// Remove all messages after front.
while (p != null) {
Message n = p.next;
if (n != null) {
if (n.target == h && n.what == what
&& (object == null || n.obj == object)) {
Message nn = n.next;
n.recycleUnchecked();
p.next = nn;
continue;
}
}
p = n;
}
}
}源码也不难，主体流程就是根绝链表节点遍历Message对象，然后比较我们指定的what、object，如果相同则删除，继续遍历下去，直到结束。
（3）、Message next()
Message next() {
....
Message prevMsg = null;
Message msg = mMessages;
if (msg != null && msg.target == null) {
// Stalled by a barrier. Find the next asynchronous message in the queue.
do {
prevMsg = msg;
msg = msg.next;
} while (msg != null && !msg.isAsynchronous());
}
if (msg != null) {
if (now < msg.when) {
// Next message is not ready. Set a timeout to wake up when it is ready.
nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);
} else {
// Got a message.
mBlocked = false;
if (prevMsg != null) {
prevMsg.next = msg.next;
} else {
mMessages = msg.next;
}
msg.next = null;
if (false) Log.v("MessageQueue", "Returning message: " + msg);
return msg;
}
} else {
// No more messages.
nextPollTimeoutMillis = -1;
}
...
}针对next()方法，我只挑出了里面的遍历部分，同样的逻辑根据链表头进行MessageQueue的遍历，返回msg。
3、Looper对象
我想把Looper对象比作“电机”、“发动机”一点不为过。我们知道Thread默认情况下是不具备消息循环的。为了使它们具备，我们需要在线程中调用prepare()方法，同时通过loop()方法获取Message。 例如：
class LooperThread extends Thread {
public Handler mHandler;
public void run() {
//将当前线程初始化loop线程
Looper.prepare();
mHandler = new Handler() {
public void handleMessage(Message msg) {
// process incoming messages here
}
};
//开始循环消息队列
Looper.loop();
}
}下面就开始对Looper源码的探究吧！首先看下常见的方法
- prepare()
- loop()
- myLooper()
- myQueue()
（1）、Looper.prepare()
这个方法用于将我们的线程转换为loop线程，它做了哪些工作？
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;
/** Initialize the current thread as a looper.
* This gives you a chance to create handlers that then reference
* this looper, before actually starting the loop. Be sure to call
* {@link #loop()} after calling this method, and end it by calling
* {@link #quit()}.
*/
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方法就是给当前Thread设置Looper对象，同时也可以知道每个Thread只能有一个Looper对象，核心就是讲线程依附的Looper对象转换为ThreadLocal类型。
（2）、Looper.loop()
在loop方法里，进行Message的遍历获取。
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();
}
}
public static Looper myLooper() {
return sThreadLocal.get();
}首先通过myLooper()方法获取Looper对象，如果Looper对象为null，则抛出异常“No Looper; Looper.prepare() wasn’t called on this thread.”。获取该Looper对象中的MessageQueue对象，进行遍历获取Message对象，同时将取出的Message进行销毁。这里我们着重注意msg.target.dispatchMessage(msg);这个方法就是调用我们的Handler的dispatchMessage方法，然后进行消息的处理。
（2）、MessageQueue myQueue()
获取Looper对象中的MessageQueue。
public static MessageQueue myQueue() {
return myLooper().mQueue;
}小结：
- Looper中包含一个MessageQueue用于存储我们的Message消息队列。
- 每个线程只能有一个Looper对象，且该Looper对象为ThreadLocal类型
- 通过Looper.prepare()方法可以将线程变成Looper线程。
4、Handler对象
我们在上篇文章中也简要的领略了Handler的使用，它提供了多个方法供我们发送消息，同时进行消息的处理。它有多个重载构造方法。
- public Handler()
- public Handler(Callback callback)
- public Handler(Looper looper)
- public Handler(Looper looper, Callback callback)
- public Handler(boolean async)
- public Handler(Callback callback, boolean async)
- public Handler(Looper looper, Callback callback, boolean async)
同时Handler内部对应着以下几个成员变量：
final MessageQueue mQueue;
final Looper mLooper;
final Callback mCallback;
final boolean mAsynchronous;
IMessenger mMessenger;它里面包含一个Looper对象、MessageQueue对象。Handler的构造方法最后都归结到两个构造方法上。
public Handler(Looper looper, Callback callback, boolean async) {
mLooper = looper;
mQueue = looper.mQueue;
mCallback = callback;
mAsynchronous = async;
}
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中通过
mLooper = looper;
mQueue = looper.mQueue;建立Looper、MessageQueue之间的关系。
我们看下Hanlder的消息发送、消息处理的方法。
- sendXXXXMessage()
- postXXXX()
- handleMessage(Message msg)：消息处理
（1）、sendXXXXMessage()
用于发送Message消息序列，它们最后都是调用sendMessageAtTime()方法。
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方法进行Handler与msg的绑定。我们发送的消息，需要我们在handleMessage(Message msg)方法中进行处理：
public interface Callback {
public boolean handleMessage(Message msg);
}
/**
* Subclasses must implement this to receive messages.
*/
public void handleMessage(Message msg) {
}这是一个空方法，子类需要重写它进行业务逻辑的处理。这里我们就需要注意构造函数中的Callback接口，这个接口就是封装了我们的handleMessage，用于我们的消息回调。
（2）、postXXXX()
用于发送Runnable的线程处理，可以在Runnable线程中直接操作UI。
public final boolean post(Runnable r)
{
return sendMessageDelayed(getPostMessage(r), 0);
}
private static Message getPostMessage(Runnable r) {
Message m = Message.obtain();
m.callback = r;
return m;
}我们可以看到在post方法中，同样是调用sendMessageXX系列，同时通过getPostMessage()方法获取一个Message对应，该Meesage的callback接口绑定到Runnable上。后面就是Looper进行变通过dispatchMessage()方法，执行Runnable中的内容。这里补充一下dispatchMessage方法的介绍：
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}这个方法中首先判断msg.callback是否为null，这是针对我们使用post发送消息处理的，然后在进行mCallback是否为null，这是针对我们的sendXXMessage进行处理的。
至此，总体的流程中的各个部分，我们已经梳理完毕。下面就总结一下，借用引用CodingMyWorld的图:
我就依照此图总结下：
1、首先创建Message对象，Message对象用Hanlder target字段存储Hanlder，实现该Message与发送源Handler的关系绑定，因为一个Handler可以发送多个消息，同样一个Message也可以被多个Handler发送，确保最后调用正确的Handler来处理该消息的回调。用Runnable callback存储Runnable。
2、创建Handler时，会指定Handler内部的Looper成员变量，同时制定成员变量mQueue = looper.mQueue；
3、Handler通过sendXXMessage()方法发送消息，该系列方法的本质是调用sendMessageAtTime方法，该方法显示判断MessageQueue是否为null，然后调用enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis)实现Message与Handler的绑定(msg.target = this)，在调用MessageQueue的插入队列方法，形成MessageQueue消息组。该消息组就是Looper内部的mQueue。
4、通过第3步，Looper内部的MessageQueue就建立了，Looper内部通过loop()方法进行遍历MessageQueue，通过msg.target.dispatchMessage(msg);调用Handler的分发事件实现消息回调的处理。
至此，整个流程就梳理通了。