从源码的角度理解Android消息处理机制

总结

与Handler共同作用的有Looper,MessageQueue,Message。我么接下来从源码的角度看看整个过程的大概实现。首先说一下每个对象的作用：

Looper:消息轮询循器，不断的从消息队列中取出消息交给Handler处理

MessageQueue:消息队列，用于存储从Handler发送过来的消息

Message:消息对象，可以携带数据

Handler:用于发送和处理消息

在Android中，主线程默认已经创建了Looper和MessageQueue对象，我们去分析一下。

ActivityThread代表了主线程对象，它的main方法是应用程序的入口，在main方法中创建了Looper。

Looper.prepareMainLooper();

ActivityThread thread = new ActivityThread();
Looper.loop();

我们看看prepareMainLooper的实现

public static void prepareMainLooper() {
prepare(false);
synchronized (Looper.class) {
if (sMainLooper != null) {
throw new IllegalStateException("The main Looper has already been prepared.");
}
sMainLooper = myLooper();
}
}

调用了带参数的prepare方法

private static void prepare(boolean quitAllowed) {
if (sThreadLocal.get() != null) {
throw new RuntimeException("Only one Looper may be created per thread");
}
//将Looper保存在ThreadLocal中
sThreadLocal.set(new Looper(quitAllowed));
}

我们看看Looper的构造方法

private Looper(boolean quitAllowed) {
//创建了消息队列
mQueue = new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}

最后是myLooper()方法

public static @Nullable Looper myLooper() {
//从ThreadLocal中取出Looper对象
return sThreadLocal.get();
}

ThreadLocal有什么作用呢?下面大概介绍一下

ThreadLocal是一个线程内部的数据存储类，通过它可以在指定的线程中存储数据，数据存储以后，只有在指定线程中可以获取到存储的数据，对于其它线程来说无法获取到数据，ThreadLocal可以在不同的线程之中互不干扰地存储并提供数据，通过ThreadLocal可以轻松获取每个线程的Looper。

总结：Looper.prepareMainLooper()方法做了三件事

创建Looper对象以及MessageQueue对象

将当前线程的Looper对象保存到ThreadLocal中

取出ThreadLocal中保存的looper，赋值给Looper的全局静态变量

接下来我们看看Looper.loop()方法

public static void loop() {
//获取Looper对象
final Looper me = myLooper();
if (me == null) {
//没有调用Looper.prepare方法会报此异常
throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
}
//取出looper对应的消息队列，消息队列是在Looper的构造函数中创建的
final MessageQueue queue = me.mQueue;
......
//死循环，可能阻塞,作用是不断从消息队列取消息
for (;;) {
//取出消息队列的消息
Message msg = queue.next();
if (msg == null) {
//没有消息说明消息队列退出了
return;
}
......
//调用消息对象的target的dispatchMessage方法分发消息
//其实这个target是Handler对象，后面我们会看到
msg.target.dispatchMessage(msg);
......
}
}

接下来我们看看这个msg.target是如何被赋值的，这就要从发送消息的过程开始分析。首先需要创建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());
}
}

mLooper = Looper.myLooper();
if (mLooper == null) {
throw new RuntimeException(
"Can't create handler inside thread that has not called Looper.prepare()");
}
//将Looper中的消息队列与当前Handler关联
mQueue = mLooper.mQueue;
mCallback = callback;
mAsynchronous = async;
}

有了Handler对象，我们开始发送消息，我们一般采用下面的方式发送消息

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) {
//取出Handler关联的消息队列，这个消息队列是在Handler的构造方法中赋值的
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);
}

接下类看看enqueueMessage方法

private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
//把Handler对象赋值给msg的target属性
msg.target = this;
if (mAsynchronous) {
msg.setAsynchronous(true);
}
return queue.enqueueMessage(msg, uptimeMillis);
}

在enqueueMessage方法中，我们终于证实了msg.target是一个Handler对象，接下来调用了消息队列的enqueueMessage方法

//此方法的作用是将消息插入到消息队列中，消息队列是线性链表结构
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(TAG, 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) {
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;
}

最后我们就要知道消息是在何时被处理的，也就是说handleMessage方法在何处被调用的，我们知道，在Looper的loop()方法中调用了下面的代码

msg.target.dispatchMessage(msg);

也就是Looper所关联的Handler对象的dispatchMessage方法

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

看到了吧，终于发现了handleMessage方法的调用。

Handler的优缺点

用到Handler，需要对比一下近似方法：

a.Activity,runOnUiThread(Runnnable)

View.post

View.postDelayed

b.Handler类

c.AsyncTask

这三种方法实际上都是基于Handler类演变而来，只是表现形式不一样，比如AsyncTask是对Handler和Thread的一个封装。三种方式区别

a中三个方法代码较复杂，难以维护，结果不清晰，容易出错

而AsyncTask在单个异步操作时较为简单，使用起来简单快捷，但在多个异步操作和UI进行交互是逻辑控制较困难，代码维护不易；

Handler类结构清晰，功能明确，多个异步执行和UI交互也容易控制，缺点是单个异步操作时相对AsyncTask代码较多

因此，在单个异步操作时选择AsyncTask较好，在多个异步操作或者特殊操作(比如定时器)时选择Handler较好