Android的消息机制（源码篇）

大致流程

将当前线程转成Looper线程；Handler发送消息，插到MessageQueue（消息队列）；looper进入循环，如果在消息队列中拿到Message就交给Handler，如果消息队列中没有消息则阻塞。

线程的分类及通信

我们都比较明白线程可分为主线程和工作线程，还有线程之间的通信分为主线程与工作线程、工作线程与工作线程（比较少听到）。

相关的对象

在上一篇基本都有提到，在这继续说一下

Message：线程间通信的信息，是消息的载体；

MessageQueue：消息队列，用于存放Handler发送的消息，里面是一个链表结构，每个线程只有一个MessageQueue对象

Looper：每个线程通过发送Message保存在MessageQueue中，Looper用于去消息队列中拿取消息；有两个重要的方法：prepare()方法，创建Looper对象并将其设置到ThreadLocal中； loop()方法，产生无限循环，每当发现一个消息，就从队列中拿取出来，最后传到Handler的handleMessage方法中。

Handler：用于发送消息和处理消息；sendMessage方法、sendXXX等方法，最终是调用sendMessageAtTime方法；除了sendMessageAtFrontOfQueue方法；只要在Looper线程中构建Handler，那么这个Handler实例就会获取该Looper线程中的MessageQueue实例的引用，此后调用sendMessage方法就会通过此引用往消息队列插入消息。

附上自己画的一张图，有点丑，但可以将就将就

Handler的创建

1.在主线程中创建

Handler handler=new Handler(new Handler.Callback() {
@Override
public boolean handleMessage(Message msg) {
return false;

}
});

2.在工作线程中创建

new Thread(new Runnable() {
@Override
public void run() {
//创建Looper
Looper.prepare();
Handler handler=new Handler(new Handler.Callback() {
@Override
public boolean handleMessage(Message msg) {
return false;

}
});
//开始循环
Looper.loop();
}
});

问题：为什么子线程需要调用Looper.prepare()和Looper.loop()。这也是我刚开始不理解的地方。后来参考别的文章和阅读源码才知道。

Looper.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));
}

其中的ThreadLocal在上一篇有讲过用法；主要是在不同线程中设置不同的值。

Looper的构造方法

private Looper(boolean quitAllowed) {
//初始化消息队列和指定为当前线程
mQueue = new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}

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) {
//队列没有消息则跳出
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为Handler，此方法为将消息分发
msg.target.dispatchMessage(msg);
} finally {
……
msg.recycleUnchecked();
}
}

这个方法比较长，省略了其中一小部分的代码。

它的作用主要是进入死循环，从消息队列获取消息，如果消息队列没有消息则会停止循环。如果有找到就进行消息的分发

dispatchMessage方法

public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {//这里就回调了handleMessage方法
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);//查看源码是一个空实现
}
}

进入此方法可知道如果创建Handler时有传进去Callback，则Callback回调了handleMessage方法。否则最后会回调Handler本身的handleMessage方法。

sendMessage方法：跟踪到最后是调用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);
}

enqueueMessage方法：

private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
msg.target = this;
if (mAsynchronous) {
msg.setAsynchronous(true);
}
//这里就是将消息加入消息队列
return queue.enqueueMessage(msg, uptimeMillis);
}

消息队列中的enqueueMessage方法

boolean enqueueMessage(Message msg, long when) {
……
//同步，因为可能同时有多个消息加入（在不同线程中）
synchronized (this) {
……
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 {
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;
}
if (needWake) {//唤醒线程（Looper循环）
nativeWake(mPtr);//此方法是一个native的方法
}
}
return true;
}

从上面代码可知，往消息队列插入消息时，会分两种情况去插入消息，如果消息队列本身是空的，在最后则会唤醒主线程去处理消息

Handler的创建：

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

这里顺便跟踪一下myLooper方法

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

总结

通过以上源码的分析，我们可以得出两点

可以知道为什么在创建Handler前要执行Looper.prepare方法。（因为没有先执行Looper.prepare()会抛异常）

Handler一创建便持有本线程的消息队列和Looper对象，所以它可以在其他线程中发送消息，最后还是会回到创建时的线程（调用HandleMessage方法）。

疑惑

不知你也会跟我一样又产生一个疑惑，在主线程中创建Handler对象不需要调用Looper.prepare和Looper.loop。

查看了文章才大概明白了是为什么。在Activity的创建过程，走到ActivityThread中的main方法

public static void main(String[] args) {
……
Looper.prepareMainLooper();//！！！
ActivityThread thread = new ActivityThread();
thread.attach(false);
……
Looper.loop();//！！！
throw new RuntimeException("Main thread loop unexpectedly exited");
}

原来是在主线程中系统会执行：Looper.prepareMainLooper()和Looper.loop();

到此消息机制的源码分析也差不多啦，可能被我拆得比较碎，但希望我们都可以从中学习到东西。