Handler的那些事
Handler的那些事
- 相关的类：Handler、Looper、Message、MessageQueue、AsyncTask、FetureTask、SerieExctor、IntentService
- Handler最大的作用就是线程间通讯，使得多个线程的数据（前提是同一个进程，这是默认条件，后续不再提及），汇集到一个统一的地方来处理，其机制是大体来说，在任意线程中产生的数据，通过某种方式加入到全局唯一的消息队列（MessageQueue），而在处理中心的线程，有一个永动机Looper，不断的轮询MessageQueue，获取队列中的Message。
初始化
首先来关注Looper，Looper的初始化，是在android.app.ActivityThread的main方法中可以看到它初始化的过程：
public static void main(String[] args) {
...
Looper.prepareMainLooper();
...
Looper.loop();
throw new RuntimeException("Main thread loop unexpectedly exited");
}
Looper.prepareMainLooper()就是初始化了全局唯一的sMainLooper：
public static void prepareMainLooper() {
prepare(false);
synchronized (Looper.class) {
if (sMainLooper != null) {
throw new IllegalStateException("The main Looper has already been prepared.");
}
sMainLooper = myLooper();
}
}
监听待处理的Message消息
随后，执行到Looper.loop();而在其后，程序竟然也就终了，真可以说，Looper的执行时间，也就是程序执行的时间了，接下来看看这个神奇的方法：
public static void loop() {
...
for (;;) {
Message msg = queue.next(); // might block
...
msg.target.dispatchMessage(msg);
...
}
}
很明显，这是一个阻塞式的无限循环，阻塞处就是queue.next();
拿到消息后的分发处理
而当拿到Message对象后，会调用其target的dispatchMessage方法，这个target其实就是Handler，也就是说这里会执行到Handler的dispatchMessage方法，再跟进：
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
msg.callback.run();
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}
这里可以发现，Message的callback，拥有最先的处理权；其次是Handler的mCallback；最后才是handleMessage方法，这也是我们定义Handler时常常复写的方法，用来实现收到消息后的处理逻辑，该方法能执行取决于两个条件：Message没有自己的callback，并且Handler的mCallback为空或者mCallback的handleMessage方法返回false（这也是Handler的消息拦截机制，在这里我们可以做一些msg的过滤）。
看到这里大家可能有点奇怪，窝草，什么鬼，你Message好容易发过来，让我Handler逮着了，结果你自己的callback又抢走了执行权，逗哥玩呢？
呵呵，可能还是源码看少了啊，还记不记得Handler了一个常规用法，就是在子线程里面我们要更新ui的经典写法：mHandler.post(new Runnable(){...})，跟下源码我们会发现，这个Runnable会被包装成一个Message对象，然后post到主线程，于是在上面dispatchMessage的逻辑中，执行我们定义在这个Ruannable的run方法里的逻辑，通过这么一圈绕，实现了在mHandler定义的线程执行run里的方法...嗯，确实绕，但就是这么个原理了。
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;
}
接着聊，还有第二处理优先权的Handler中的mCallback，它只在Handler构造中被初始化，并且是final的，上面有说到这是Handler消息的一种过滤机制。于是创建Handler时有两种等价的写法：
Handler myHandler1 = new Handler(){
@Override
public void handleMessage(Message msg) {
...
super.handleMessage(msg);
}
};
Handler myHandler2 = new Handler(new Handler.Callback() {
@Override
public boolean handleMessage(Message msg) {
...
return false;
}
});
好了，消息Message的处理流程大致上说完了，接下来聊聊Message的发送流程。
消息发送-Message对象获取
Message可以直接通过new关键字来创建对象，但是更推荐使用Message.obtain()的方式，包括myHandler.obtainMessage()都是一样的，这里使用了消息池(message pool)来管理消息，来看源码：
Handler类中：
public final Message obtainMessage(){
return Message.obtain(this);
}
Message类中：
public static Message obtain(Handler h) {
Message m = obtain();
m.target = h;
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();
}
消息发送-添加消息到消息列表
Handler的一堆post方法，无论是Runnable，还是EmptyMessage，最终都是得到一个Message对象，然后通过enqueueMessage方法，将其加入到MessageQueue中：
Handler类：
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
msg.target = this;
if (mAsynchronous) {
msg.setAsynchronous(true);
}
return queue.enqueueMessage(msg, uptimeMillis);
}
MessageQueue：
boolean enqueueMessage(Message msg, long when) {
...
synchronized (this) {
...
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;
}
这里的代码比较高能，我们发现他并没有用一个列表或者队列的数据结构来维护，而是用mMessages来表示当前等待处理的Message，每一个Message的实例中指定了他的后继节点Message，以此来环环相扣形成一个Message的链表，enqueueMessage方法的核心逻辑就是通过比对Message的when值，从小到大排序，把需要添加进队列的Message安排到正确的位置。
消息发送撤回机制
我们知道Handler发送的延时消息是可以取消撤回的，他提供了removeXXX系列api来做这个事，最终都是调用MessageQueue的removeXXX方法：
public final void removeCallbacks(Runnable r){
mQueue.removeMessages(this, r, null);
}
public final void removeMessages(int what) {
mQueue.removeMessages(this, what, null);
}
...
MessageQueue类：
void removeCallbacksAndMessages(Handler h, Object object) {
...
synchronized (this) {
Message p = mMessages;
// Remove all messages at front.
while (p != null && p.target == h
&& (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 && (object == null || n.obj == object)) {
Message nn = n.next;
n.recycleUnchecked();
p.next = nn;
continue;
}
}
p = n;
}
}
}
可以看到，这是与添加进队列类似的处理手法，都是遍历待处理的Message链表，符合移除条件的Message对象，都会执行recycleUnchecked()清理，这些对象并不会被销毁，而是清理完毕后进入消息池等待复用：
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++;
}
}
}