- 《Android Handler机制》
- 《Android Handler分析（一） Handler和Message详解》
- 《Android Handler分析 (二) MessageQueue详解》
- 《Android Handler分析 (三) Looper详解和Handler其他知识》
- 《Android 中的 HandlerThread 类详解》
作为一个Android程序员，我想大家都知道在做一些比较耗时的操作的时候都不会放在主线程，比如网络请求、数据库操作等(尤其是网络请求，在Android4.0之后强制不能放在主线程中执行，否则抛出android.os.NetworkOnMainThreadException异常)，而更新UI的操作的都是由UI线程处理。那么有这样一个需求，我在一个新的线程中获取到数据，然后设置到界面上，这就涉及到了两个线程，用于更新界面的UI线程不知道什么时候数据获取完成可以更新界面了，那怎么办呢？Google就给我们提供了一个解决方案，也就是我们今天主要说明的内容——Android中的Handler消息机制。
首先来一个简单使用：
private static final int HANDLER_TEST_WHAT = 0x01; // 定义测试what
// 创建Handler对象，并重写handleMessage()方法处理消息
private Handler handler = new Handler(){
@Override
public void handleMessage(Message msg) {
int what = msg.what; // 获取消息的what
// 通过what对消息进行判断，不同消息不同的处理
if(what == HANDLER_TEST_WHAT){
// 处理消息
}
}
};
// 创建一个子线程发送消息
new Thread(){
@Override
public void run() {
Message message = Message.obtain(); // 创建一个消息对象，使用obtain()重用回收的消息对象
message.what = HANDLER_TEST_WHAT; // 设置Message的 what
handler.sendMessage(message); // 发送一个消息
}
}.start();
上面就是一个简单的例子，在子线程发送一个消息，然后在主线程就可以对消息进行处理，当然包括更新UI或者其他操作。
下面我们就从源码的角度查看与分析一下Handler消息机制，他是怎样将一个子线程的数据传递到主线程中的。
介绍Handler机制之前，首先了解几个概念：
- Message：消息，理解为线程间通讯的数据单元。例如后台线程在处理数据完毕后需要更新UI，则可发送一条包含更新信息的Message给UI线程。
- MessageQueue：消息队列，用来存放通过Handler发布的消息并按时间进行排序，按照先进先出执行。
- Handler：Handler是Message的主要处理者，负责将Message添加到消息队列以及对消息队列中的Message进行处理。
- Looper：轮询器，扮演MessageQueue和Handler之间桥梁的角色，循环取出MessageQueue里面的Message，并交付给相应的Handler进行处理。
消息机制分析
从上面的示例中，我们先创建了一个Handler对象并且重写了 handleMessage() 方法用来处理接收到的消息，而消息的发送是通过 Handler 的sendMessage() 方法。也可以说，Handler机制是由 sendMessage() 方法开始，到 handleMessage() 方法结束，现在我们就来一步一步看看数据是怎样传递的，线程又是怎样切换的。
首先看看创建 Handler
最终调用的是 带两个参数 的构造方法，如下：
public Handler(@Nullable Callback callback, boolean async) {
mLooper = Looper.myLooper();
if (mLooper == null) {
throw new RuntimeException(
"Can't create handler inside thread " + Thread.currentThread()
+ " that has not called Looper.prepare()");
}
mQueue = mLooper.mQueue;
}
说明：
-
Looper.myLooper()：获取当前线程的 Looper 对象，也就是线程需要是一个 Looper 线程，主线程就是一个 Looper 线程，主线程为什么是一个Looper线程以及怎样将一个线程变为 Looper 线程，在《Android Handler分析 (三) Looper详解和Handler其他知识》中有说到。
public static @Nullable Looper myLooper() { return sThreadLocal.get(); } -
mLooper.mQueue：就是一个 MessageQueue 对象，他是在 Looper 构造方法中初始化的
private Looper(boolean quitAllowed) { mQueue = new MessageQueue(quitAllowed); mThread = Thread.currentThread(); }
我们创建了 Handler 对象之后，然后通过 Handler 的 sendMessage() 方法发送一个 Message，接下来看看 sendMessage() 方法做了写什么事
Handler#sendMessage() 方法
public final boolean sendMessage(@NonNull Message msg) {
return sendMessageDelayed(msg, 0);
}
public final boolean sendMessageDelayed(@NonNull Message msg, long delayMillis) {
if (delayMillis < 0) {
delayMillis = 0;
}
return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
}
public boolean sendMessageAtTime(@NonNull 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(@NonNull MessageQueue queue, @NonNull Message msg, long uptimeMillis) {
// 注意这行代码，将 Message 的 target 变量赋值成 this，也就是当前 Handler 对象
msg.target = this;
msg.workSourceUid = ThreadLocalWorkSource.getUid();
if (mAsynchronous) {
msg.setAsynchronous(true);
}
return queue.enqueueMessage(msg, uptimeMillis);
}
说明：
-
sendMessage()方法调用了一些 Message 类自身的发送方法，主要是处理消息发送时间（立马发送还是延迟发送等） - 最终调用
enqueueMessage()方法，在这个方法中又调用了queue.enqueueMessage(msg, uptimeMillis)，queue 就是 MessageQueue，所以查看一下 MessageQueue 中的enqueueMessage()方法 - 重点注意
enqueueMessage()方法中的msg.target = this代码，将 Message 的target变量赋值成this，也就是当前 Handler对象
MessageQueue#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 {
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;
}
这个方法所做的事情就是将 Message 对象根据发送时间添加到队列中，方法的具体分析在 《Android Handler分析 (二) MessageQueue详解》中。
Message 消息对象添加到 MessageQueue 中之后，在哪里取出来，并且传递到 handleMessage() 方法呢？
这里我们就有必要先说一下 Looper 线程了，一个类变为Looper线程并且能处理消息，主要有两步：
- 调用 Looper.prepare() 方法
- 调用 Looper.loop() 方法开始轮询
至于这两个方法具内容是什么我们这里就不说了，在《Android Handler分析 (三) Looper详解和Handler其他知识》 中有分析，只需要知道 loop() 方法最重要的作用就是不断的循环调用 MessageQueue 的 next() 方法去获取 Message ，然后进行处理，而 MessageQueue 的 next() 方法的消息分析在 《Android Handler分析 (二) MessageQueue详解》中，它的主要作用就是按照顺序从队列里面取出 Message。
所以我们直接看 MessageQueue.next() 取到消息之后 Looper.loop() 方法是怎样处理的，核心代码如下：
public static void loop() {
final Looper me = myLooper();
final MessageQueue queue = me.mQueue;
Message msg = queue.next();
try {
msg.target.dispatchMessage(msg);
} catch (Exception exception) {
} finally {
}
}
说明：
通过获取的 Message 对象的变量 target, 调用它的 dispatchMessage() 方法，并且将 msg 对象传递给 dispatchMessage() 方法。在上面，我们已经知道了 target 变量表示的就是 Handler，所以这里调用的就是 Handler 的 dispatchMessage() 方法了。
Handler#dispatchMessage() 方法
public void dispatchMessage(@NonNull Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}
在 dispatchMessage() 方法中调用了 handleMessage(msg) 方法并传递 Message，这个方法我们在创建 Handler 时重写了。所以就走到了我们自己处理消息的部分。因为我们的这个Handler是在主线程创建的并且绑定的也是主线程的Looper，所以这个方法就在主线程当中执行了。
