前言
最近通过微信公众号推文以及博客文章学习了Android的消息机制的原理，然后抽空写下了这篇文章，对自己学到知识进行梳理，也方便以后自己查阅。
主线程不处理耗时操作，子线程不更新UI
Handler消息处理机制在Android中占有非常重要的地位
消息机制的大概流程：
系统启动后，系统主线程会创建一个Looper对象，然后调用Looper.loop()开启一个死循环，循环会不断地从消息队列中（MessageQueue）中取出待处理的消息（Message），Looper取到消息后就会回调Handler中的方法处理消息。消息队列中的消息是从哪里来的呢？没错，就是我们通过Handler发送过去的。大概流程如下图：
消息机制源码分析：
如果我们想使用消息机制进行更新UI的话有两种方法：
- 创建Handler时传入一个Handler.Callback对象，然后重写handleMessage()
private Handler mHandler = new Handler(new Handler.Callback() {
@Override
public boolean handleMessage(Message msg) {
return false;
}
});
- 调用Handler的post方法传入一个Runnable对象
Handler handler = new Handler();
handler.post(new Runnable() {
@Override
public void run() {
try {
Thread.sleep(2000);
setText();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
子线程不是不能更新UI吗？怎么第二种方法更新UI的时候好像是在子线程。接下来看看源码吧，这个问题看完源码后自然会有答案。
首先看看上面使用到的Handler的两个构造函数
public Handler() {
this(null, false);
}
public Handler(Callback callback) {
this(callback, false);
}
上面两个构造函数最终都是调用Handler(Callback callback, boolean async)，接着往下看
public Handler(Callback callback, boolean async) {
//省略代码
//这里获取了一个Looper对象
mLooper = Looper.myLooper();
//Looper对象很重要，如果当前线程中没有Looper对象的话，会抛出异常，提示用户应该用Looper.prepare()创建一个
if (mLooper == null) {
throw new RuntimeException("Can't create handler inside thread that has not called Looper.prepare()");
}
//从Looper中获取消息队列对象
mQueue = mLooper.mQueue;
mCallback = callback;
mAsynchronous = async;
}
到此为止，一个Handler就创建好了。然后呢，如果是使用第一种方式更新UI，就需要调用Handler的sendMessage()发送消息了，看看这一步是怎么处理的吧
//直接把延迟时间设为0
public final boolean sendMessage(Message msg) {
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) {
//在这里，把this，也就是当前Handler对象封装进消息对象中
msg.target = this;
if (mAsynchronous) {
msg.setAsynchronous(true);
}
//最终调用消息队列中的enqueueMessage()方法
return queue.enqueueMessage(msg, uptimeMillis);
}
最终是调用MessageQueue中的enqueueMessage方法
boolean enqueueMessage(Message msg, long when) {
//省略代码...
synchronized (this) {
//...
msg.when = when;
Message p = mMessages;
boolean needWake;
//注意看when<p.when，可以看出消息队列中的消息是按延迟时间从小到大排序的
if (p == null || when == 0 || when < p.when) { //把消息插入到表头
msg.next = p;
mMessages = msg;
needWake = mBlocked;
} else {
Message prev;
for (;;) {
prev = p;
p = p.next;
if (p == null || when < p.when) {
break;
}
//...
}
msg.next = p; // invariant: p == prev.next
prev.next = msg;
}
//...
}
return true;
}
从上面的源码中可以看出来，MessageQueue中的数据结构是单链表。到这里，就已经把消息成功插入到消息队列当中去了。好了，第一种方法已经成功插入消息了，接下来看看第二种方法了，从哪里开始看起呢？没错，就是从post()开始看：
public final boolean post(Runnable r) {
return sendMessageDelayed(getPostMessage(r), 0);
}
post()方法里面调用了sendMessageDelayed()方法，那最终还是调用enqueueMessage()，这里面的流程再上一步已经看过了，唯一的不同就是这个getPostMessage()方法：
private static Message getPostMessage(Runnable r) {
Message m = Message.obtain();
m.callback = r;
return m;
}
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();
}
在getPostMessage中把Runnable封装进了消息当中，最终把这个消息插入到消息队列里。
这时候，就已经成功把消息（Message）插入到MessageQueue中了，并且知道了Handler把自己封装进了Message当中。走到这里，我们好像走进了一个死胡同，走不下去了？先来看看下面几个问题：
- Looper对象是在哪里被创建的（好像我们都没有创建过Looper对象）？
- Handler中的handlerMessage()方法是怎么被回调的？
我们在上面的步骤中，没有创建过Looper对象，而Looper对象却已经存在了，那唯一的一种可能就是，当我们启动系统的时候，系统已经帮我们创建好Looper对象了。我们在ActivityThread类中找到main()方法，ActivityThread类是一个隐藏类，我们可以在SDK文件夹中查找出来：
public static void main(String[] args) {
//...
Looper.prepareMainLooper(); //创建一个Looper对象
//...
Looper.loop(); //开启循环
//...
}
果然，在main()中发现了Looper。main()方法中通过Looper.prepareMainLooper()创建一个Looper对象，prepareMainLooper()方法实际上就是调用Looper.prepare(boolean quitAllowed)，这个方法是不是很熟悉，没有记错，它就是在Hanlder构造方法里面的异常提示中出现的方法，不过main()中调用的是带参的prepare()方法，而我们之前看过的是Looper.prepare()，先看看源码：
public static void prepareMainLooper() {
prepare(false);
synchronized (Looper.class) {
if (sMainLooper != null) {
throw new IllegalStateException("The main Looper has already been prepared.");
}
sMainLooper = myLooper();
}
}
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));
}
public static void prepare() {
prepare(true);
}
可以看到Looper.prepare()最终也是调用Looper.prepare(boolean quitAllowed)。
很简单，prepare()中就是new了一个Looper，并把Looper set进ThreadLocal中（ThreadLocal是什么来的？我暂时还没有去了解，有时间会补充），所以Looper在系统启动时就创建好了，创建Handler时才不会报错
Looper创建完成之后，然后Looper.loop()就会开启一个循环，开启循环做什么呢？就是之前说过的，从MessageQueue中不断的取出消息来
//下面省略了部分代码
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;
for (;;) {
Message msg = queue.next(); // might block
if (msg == null) {
// No message indicates that the message queue is quitting.
return;
}
try {
msg.target.dispatchMessage(msg);
} finally {
//...
}
}
}
很明显可以看出loop方法一直遍历MessageQueue，阻塞线程，直到获取到一个Message，然后调用Message的一个成员变量target的dispatchMessage方法。之前说过了，target其实就是Handler，dispatchMessage方法最终就调用我们重写的Handler的handlerMessage方法
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}
到这里好像已经都结束了，对了，好像还有之前使用post()方法时的一个问题，看看上面的源码，msg.callback不正是当初使用post传进来的Runnable，它不为空的话就调用handleCallback()：
private static void handleCallback(Message message) {
//直接调用子线程的run方法
message.callback.run();
}
由Java多线程的知识，主线程直接调用子线程的run方法，那相当于还是在主线程中，和普通的调用方法没有区别，所以我们用post传入Runnable更新UI的时候不会报错。
以上就是消息机制的原理了，让我们整理一下上面的知识：
- Handler：在消息机制中，是作为消息的发送方和处理方。消息在一个线程中通过Handler发送到MessageQueue中。
- Looper：在消息机制中，是作为消息队列的管家。不停的从消息队列中获取消息，获取到消息后，根据Message中绑定的Handler对象调用Handler中的dispatchMessage方法，进而调用到开发者重写的handlerMessage方法进行消息的处理
- MessageQueue和Message：MessageQueue就是存放Message的地方，实质上是一个单链表的结构，有新的Message来的时候，就把插入到消息队列，当Looper来取消息时就把表头的Message给它。Looper拿到消息后，可以从Message中拿到消息的发送方Handler。
知道消息机制的原理后，我们就可以轻松的在任何线程下使用handler了：
new Thread() {
@Override
public void run() {
Looper.prepare();
Looper.loop();
Handler handler = new Handler(new Handler.Callback() {
@Override
public boolean handleMessage(Message msg) {
return false;
}
})；
}
}.start();
- 首先用Looper.prepare()创建一个Looper并初始化Looper持有的MessageQueue
- 然后用Looper.loop()方法开启循环，从MessageQueue中取消息，并调用handler的dispatchMessage方法处理消息，如果消息队列里面没有消息，循环就会阻塞进入休眠状态，等有消息时就会被唤醒
- 最后再new一个Handler，Handler构造方法会获取到Looper和Looper的MessageQueue对象，然后通过sendMessage方法往消息队列中插入消息。
最后，我们对消息机制有一些了解了，先写这么多吧，如有错误欢迎指出。
扫一扫
1700
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
