Android消息机制——深入理解Handler
Handler是什么
Handler允许向一个线程的消息队列发送和处理Message和Runnable两种对象。每一个Handler实例与一个线程和其消息队列关联。当你新建一个Handler时，它会与创建它的线程和这个线程的消息队列绑定，从这时起，Handler就可以分发消息和任务到消息队列以及从消息队列中执行消息和任务。
Handler主要有两个用法：
- 定时消息或任务，分发在某一时刻执行的消息或任务
- 将一个动作放入队列中，但是这个动作的执行在不是本线程中
当一个应用进程创建后，主线程会运行一个消息队列负责顶层应用对象（activities，broadcast receivers，等等）和任何创建的窗体。你也可以创建自己的线程，然后通过Handler来与主线程通信。
Handler的使用
常用情景——更新UI
Handler的一个重要使用场景就是在主线程中声明一个Handler对象，然后在一个线程中执行费时操作，执行完之后需要更新UI。但是我们知道非UI线程是不可以更新UI的，此时就可以通过Handler来发送一个消息，这样主线程中的Handler就可以接受到这个消息然后更新UI了。
public class MainActivity extends AppCompatActivity {
private Handler handler = new Handler() {
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
//Handler收到了非UI线程的消息后，更新UI，因为这个Handler是在主线程中的
case 1:
showTv.setText("Hello,Handler");
break;
default:
break;
}
}
};
private TextView showTv;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
showTv = (TextView) findViewById(R.id.tv_show);
doWork();
}
/**
* Handler使用场景1——更新UI
* 开启一个线程执行耗时操作，执行完之后，通过Handler发送一个消息
*
*/
private void doWork() {
new Thread(new Runnable() {
@Override
public void run() {
//模拟耗时操作
try {
TimeUnit.SECONDS.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
handler.sendEmptyMessage(1);
}
}).start();
}
}上面的代码，doWork模拟耗时操作，是在非UI线程中执行的，执行后之后，handler发送了一个消息出去，当handler收到这个消息时就可以更新TextView了。运行程序可以发现，在程序启动后10s，文本由“Hello World”变成了“Hello Handler”。
定时任务
所谓定时任务，就是设置发送消息的时间，这个时间可以是延迟一定时间得到相对时间或设置绝对时间。常见的场景有应用启动的闪屏，比如说3s后进行主界面，就可以设置3s之后再发送消息；还有倒计时的实现，比如游戏计时器。下面就实现一个简单的计时器。代码如下：
private Handler handler = new Handler() {
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
//Handler收到了计时器中的消息
case 2:
initVal--;
if (initVal < 0)
break;
timerTv.setText(initVal + "s");
//下一秒继续计时
startTimer();
break;
default:
break;
}
}
};
private TextView timerTv;
private int initVal = 60;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
timerTv = (TextView) findViewById(R.id.tv_timer);
timerTv.setText(initVal + "s");
startTimer();
}
/**
* 通过Handler的定时消息实现计时器
*/
private void startTimer() {
//1s之后的消息
handler.sendEmptyMessageDelayed(2, 1000);
}从上面的代码可以看到startTimer方法中调用的是sendEmptyMessageDelayed方法，使用的是相对时间；而如果要使用绝对时间的话，可以使用sendEmptyMessageAtTime方法。上面的代码实现的效果就是一个1分钟倒计时器，1s钟发一次消息，进行一次更新。
效果如下：
非主线程中Handler的使用
上面两个例子都展示的是主线程中的Handler是如何使用的。在前面说到，Handler是可以用于任何线程的，不一定就非得是主线程。至于在非UI线程中使用，比起主线程中使用，稍微有点复杂，得遵循以下的格式：
private Handler handler2;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
//非主线程使用Handler
initHandler();
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
otherThread();
}
//非UI线程初始化Handler
private void initHandler() {
new Thread(new Runnable() {
@Override
public void run() {
//Step 1:调用Looper.prepare()
Looper.prepare();
//Step 2:实例化Handler，重写handleMessage方法
handler2 = new Handler() {
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case 1:
Log.i("MainActivity", "Other Thread Completed");
break;
}
}
};
//Step 3:调用Looper.loop()
Looper.loop();
}
}).start();
}
private void otherThread() {
new Thread(new Runnable() {
@Override
public void run() {
//模拟耗时任务
try {
TimeUnit.SECONDS.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
//发送消息
handler2.sendEmptyMessage(1);
}
}).start();
}
上面的代码中首先在initHandler中的一个线程中初始化Handler实例，步骤有三步：
- 调用Looper.prepare()方法
- 实例化Handler
- 调用Looper.loop()方法
缺少第一步将会抛出异常；缺少第二步，别的线程就无法使用Handler发送消息了；缺少第三步，Handler就不会收到消息也就不可以处理消息了。至于为什么是这样，下面分析源码时会讲到。
而otherThread方法中还是模拟一个耗时任务，在任务完成后发消息给Handler，而Handler收到消息后就是打印Log信息，具体如下：
11-24 06:27:04.084 1488-1512/system_process I/ActivityManager: Displayed com.xks.handlerdemo/.MainActivity: +4s884ms
11-24 06:27:13.062 27218-27267/com.xks.handlerdemo I/MainActivity: Other Thread Completed从时间可以看到，从界面显示到Log打印，期间差不多相隔10s。
分析完Handler的使用之后，下面将从源码的角度解释Handler的原理。
Handler源码分析
Handler使用步骤分析
在上面关于Handler的使用部分，讲到了在非主线程中使用Handler的三个步骤，下面我们就以非主线程中使用Handler为例来开始源码分析之旅。
Loop.prepare()
Looper类用来给一个线程执行消息循环。线程默认是没有关联的消息循环的；为了创建一个消息循环，需要在一个线程中调用prepare方法来运行这个循环，loop方法会使它不断地处理消息，除非循环停止。
public static void prepare() {
prepare(true);
}
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));
}上面的代码有一个sThreadLocal变量，这是一个ThreadLocl类型的变量，保存每个线程的Looper变量。从上面的代码可以看到每个线程只能有一个Looper。最后新建一个Looper对象，然后保存在sThreadLocal中。下面看Looper的构造方法：
private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}从上面的代码可以看出，Looper的构造方法实例化了MessageQueue对象，保存了线程变量。至此，Looper与线程关联了并且创建好了MessageQueue对象，MessageQueue对象是保存消息的一个队列，后面会具体讲到。
看完了第一步之后，我们再看第二步，Handler的实例化。
Handler实例化
Handler有很多个重载的构造方法，如下：
public Handler() {
this(null, false);
}
public Handler(Callback callback) {
this(callback, false);
}
public Handler(Looper looper) {
this(looper, null, false);
}
public Handler(Looper looper, Callback callback) {
this(looper, callback, false);
}
public Handler(boolean async) {
this(null, async);
}
public Handler(Callback callback, boolean async) {
if (FIND_POTENTIAL_LEAKS) {
final Class 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());
}
}
//从sThreadLocal中根据本线程得到Looper
mLooper = Looper.myLooper();
//如果本线程没有Looper
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;
}
public Handler(Looper looper, Callback callback, boolean async) {
mLooper = looper;
mQueue = looper.mQueue;
mCallback = callback;
mAsynchronous = async;
}
从上面的代码可以看出，Handler的初始化主要涉及三个值：mLooper、mQueue、mCallback和mAsynchronous。从上面的代码可以看到，所有的构造方法最终都是调用后面两个构造方法，一个外部不提供Looper，一个外部提供Looper。先看外部提供Looper的，直接就是赋值，在上面第一步提到了，Looper.prepare()之后，消息队列也创建好了。
对于外部不提供Looper的情况，则需要调用Looper.myLooper()获取Looper，myLooper方法如下：
public static @Nullable Looper myLooper() {
return sThreadLocal.get();
}该方法从sThreadLocal中根据线程取出Looper.prepare()中存入的Looper对象。得到了Looper，也就得到了MessageQueue。
Callback参数是一个处理消息的回调，async参数设置消息队列中的每个消息是否异步。
分析完上面Handler的构造方法后，我们知道了如果不传入Looper对象，那么将会使用本线程的Looper。这也就解释了在非UI线程中需要首先调用Looper.prepare()，因为在那里创建了Looper对象并保存在了sThreadLocal中；那么问题来了:
在UI线程中初始化的Handler，它的Looper是在哪里赋值的？
主线程中Looper的实例化
对于这个问题，我们看应用的主线程ActivityThread中的main方法：
public static void main(String[] args) {
//与本文无关的代码
...
Looper.prepareMainLooper();
ActivityThread thread = new ActivityThread();
thread.attach(false);
if (sMainThreadHandler == null) {
sMainThreadHandler = thread.getHandler();
}
if (false) {
Looper.myLooper().setMessageLogging(new
LogPrinter(Log.DEBUG, "ActivityThread"));
}
// End of event ActivityThreadMain.
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
Looper.loop();
throw new RuntimeException("Main thread loop unexpectedly exited");
}从上面的代码我们可以看到，首先调用prepareMainLooper方法，然后得到一个sMainThreadHandler，最后调用Looper.loop方法，好像也是3步。下面就看下这三步到底做了些什么？
Looper.prepareMainLooper()方法
public static void prepareMainLooper() {
//等同于Looper.prepare()
prepare(false);
synchronized (Looper.class) {
if (sMainLooper != null) {
throw new IllegalStateException("The main Looper has already been prepared.");
}
sMainLooper = myLooper();
}从上面的代码可以看到，首先调用prepare(false)方法，这和显式的调用Looper.prepare()是同样的效果，这句执行完后，主线程中的Looper就创建好了并且被保存在了sThreadLocal中了。接下来，判断sMainLooper这个变量是否为null，抛出异常，这个异常和prepare()方法中抛出的异常有些类似，都说明每个线程只能有一个Looper，最后是调用myLooper方法将从sThreadLocal中取出的Looper赋值给sMainLooper对象。所以，至此，主线程的Looper创建成功，并且其值保存在Looper中的sMainLooper变量中。
如果想使用这个Looper，可以调用getMainLooper方法得到这个变量：
public static Looper getMainLooper() {
synchronized (Looper.class) {
return sMainLooper;
}
}所以，可以看到主线程中的prepareMainLooper方法除了与prepare()方法同等作用后，还将Looper保存了下来，这样非UI线程也是可以使用的。
Handler的实例化
如果sMainThreadHandler为null，那么调用getHandler方法获取，下面是该方法的实现：
final Handler getHandler() {
return mH;
}从代码可以看出，返回值是一个Handler。那么mH是个什么呢？
final H mH = new H();从上述代码可以看到mH是ActivityThread的一个字段，并且直接初始化了。而H是ActivtyThread的一个嵌套类，如下：
private class H extends Handler {
...
public void handleMessage(Message msg) {
if (DEBUG_MESSAGES) Slog.v(TAG, ">>> handling: " + codeToString(msg.what));
switch (msg.what) {
case LAUNCH_ACTIVITY: {
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityStart");
final ActivityClientRecord r = (ActivityClientRecord) msg.obj;
r.packageInfo = getPackageInfoNoCheck(
r.activityInfo.applicationInfo, r.compatInfo);
handleLaunchActivity(r, null);
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
} break;
//还有很多case
...
}
}
}从上面可以看到，H继承自Handler并重写了handleMessage方法，这个H主要负责应用Activity、Broadcast等的消息传递。
至此，主线程也完成了第二步操作。
Looper.loop()方法
在主线程的最后，可以看到调用了Looper.loop()方法。所以说，在主线程中使用Handler也遵循了那三步。从分析主线程的Handler创建中我们发现了，一个线程对应一个Looper，一个Looper对象一个MessageQueue，但是一个线程里可以有多个处理消息和发送消息的Handler。 这个后面会详细讲解。
Looper.loop()方法
接下来，我们分析最后一步，Looper.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) {
// No message indicates that the message queue is quitting.
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.traceBegin(traceTag, msg.target.getTraceName(msg));
}
//分发消息
try {
msg.target.dispatchMessage(msg);
} finally {
if (traceTag != 0) {
Trace.traceEnd(traceTag);
}
}
if (logging != null) {
logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);
}
// Make sure that during the course of dispatching the
// identity of the thread wasn't corrupted.
final long newIdent = Binder.clearCallingIdentity();
if (ident != newIdent) {
Log.wtf(TAG, "Thread identity changed from 0x"
+ Long.toHexString(ident) + " to 0x"
+ Long.toHexString(newIdent) + " while dispatching to "
+ msg.target.getClass().getName() + " "
+ msg.callback + " what=" + msg.what);
}
msg.recycleUnchecked();
}
}从上面的代码可以看到，首先获取Looper对象和MessageQueue对象，然后进入死循环，尝试从消息队列中取消息，如果可以取到消息，则会调用msg.target.dispatchMessage方法进行消息的分发。
从上面可以看到，loop方法之后才会从消息队列中取消息，也就是说如果不调用loop方法，那么尽管可以往消息队列中发消息，但是却因为不取走消息，所以也就没有处理了。
总结
经过上面的分析后，我们可以看出每一步的作用：
1. Looper.prepare()方法创建Looper以及MessageQueue
- Handler实例化后，其与Looper与MessageQueue关联；可以通过Handler发送消息以及重写handleMessage方法编写处理逻辑
- Looper.loop()方法后开始从消息队列中取消息给Handler处理。
Handler发送消息、处理消息和删除消息
在理解了Looper、Handler、MessageQueue三者的关系之后，我们再看Handler发送消息和处理消息的原理。
在看Handler发送消息之前，先看一下接下来要打交通的Message类。
Message类
Message可以用来描述消息和包含数据，Handler发送的都是这个对象。主要有如下几个字段：
public int what;
public int arg1;
public int arg2;
public Object obj;
public Messenger replyTo;
public int sendingUid = -1;
/*package*/ static final int FLAG_IN_USE = 1 << 0;
/*package*/ static final int FLAG_ASYNCHRONOUS = 1 << 1;
/*package*/ static final int FLAGS_TO_CLEAR_ON_COPY_FROM = FLAG_IN_USE;
/*package*/ int flags;
/*package*/ long when;
/*package*/ Bundle data;
/*package*/ Handler target;
/*package*/ Runnable callback;
/*package*/ Message next;
从上面可以看到，字段主要分为两类，一类公有的，包括what、arg1、arg2、obj和replyTo；一类访问为包权限，target、callback和next等。从这可以看出Message是一个链表中的节点，MessageQueue是一个单链表结构的队列。
消息对象池
Message类中维持着一个消息池，参数如下：
private static final Object sPoolSync = new Object();
private static Message sPool;
private static int sPoolSize = 0;
private static final int MAX_POOL_SIZE = 50;而如果需要获取一个Message对象，推荐使用obtain方法而不是构造方法，如下：
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();
}上面的方法主要是从对象池中得到消息，如果对象池为空，那么就新建一个Message并返回。既然有对象的获取，那么自然有对象的回收，回收在recycle方法中，如下：
public void recycle() {
//如果仍在使用中
if (isInUse()) {
if (gCheckRecycle) {
throw new IllegalStateException("This message cannot be recycled because it "
+ "is still in use.");
}
return;
}
//不再使用中了，可以进行回收
recycleUnchecked();
}
void recycleUnchecked() {
//清除状态
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++;
}
}
}上面的代码解释了如何将消息回收到消息对象池中的。
看完了Message类后，再来看Handler是如何与Message对象打交通的。
发送消息
Handler可以发送消息或者Runnbale对象，有很多发送的方法，还可以设置时间限制，所以其发送主要有两个参数，一个消息，一个时间。下面看一个方法：
public final boolean sendEmptyMessageDelayed(int what, long delayMillis) {
//得到消息对象
Message msg = Message.obtain();
msg.what = what;
return sendMessageDelayed(msg, 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);
}很多发送方法，比如sendEmptyMessage、sendEmptyMessageDelayed等最终都会进入这个方法。从上面的代码可以看到，最终调用了enqueueMessage方法将消息入队，代码如下：
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
//赋值target属性
msg.target = this;
//如果设置了异步
if (mAsynchronous) {
msg.setAsynchronous(true);
}
//调用MessageQueue的enqueueMessage方法
return queue.enqueueMessage(msg, uptimeMillis);
}可以看到，首先将Message与Handler关联，因为处理消息时要根据消息找到处理该消息的Handler；设置消息是否是异步属性，最后调用MessageQueue鄂enqueueMessage方法将消息入队。
下面是MessageQueue的enqueueMessage方法：
boolean enqueueMessage(Message msg, long when) {
//如果Handler为null，异常；因为处理时找不到谁该处理这条消息
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;
}
//置Flag
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;
}从入队，可以看到MessageQueue内部维持的是一个单链表结构的优先队列，并且其内部的节点是按照执行时间先后顺序排序的，也就是队头的节点总是最先执行的。下图展示了插入一个时间节点为5的消息
上图中，当插入一个时间节点为5的消息，那么将会插入到4和6之间。
上述代码就是将消息放入队列中，下面分析从消息中取出消息。
处理消息
在分析Looper.loop()方法中，我们知道了从消息队列中取消息发生于此，会调用MessageQueue的next方法获取消息，next方法如下：
Message next() {
//如果消息队列退出了
final long ptr = mPtr;
if (ptr == 0) {
return null;
}
int pendingIdleHandlerCount = -1; // -1 only during first iteration
int nextPollTimeoutMillis = 0;
//死循环
for (;;) {
if (nextPollTimeoutMillis != 0) {
Binder.flushPendingCommands();
}
nativePollOnce(ptr, nextPollTimeoutMillis);
synchronized (this) {
//轮询消息，如果有则返回
final long now = SystemClock.uptimeMillis();
Message prevMsg = null;
//队头消息
Message msg = mMessages;
if (msg != null && msg.target == null) {
// Stalled by a barrier. Find the next asynchronous message in the queue.
do {
prevMsg = msg;
msg = msg.next;
} while (msg != null && !msg.isAsynchronous());
}
if (msg != null) {
//如果还没到执行时间，得到下次轮询时间
if (now < msg.when) {
// 设置轮询时间为消息剩余时间
nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);
} else {
// 得到一个消息
mBlocked = false;
//队列中节点设置
if (prevMsg != null) {
prevMsg.next = msg.next;
} else {
mMessages = msg.next;
}
msg.next = null;
if (DEBUG) Log.v(TAG, "Returning message: " + msg);
//设置消息可重用并返回
msg.markInUse();
return msg;
}
} else {
// No more messages.
nextPollTimeoutMillis = -1;
}
// 如果退出了
if (mQuitting) {
dispose();
return null;
}
// If first time idle, then get the number of idlers to run.
// Idle handles only run if the queue is empty or if the first message
// in the queue (possibly a barrier) is due to be handled in the future.
if (pendingIdleHandlerCount < 0
&& (mMessages == null || now < mMessages.when)) {
pendingIdleHandlerCount = mIdleHandlers.size();
}
if (pendingIdleHandlerCount <= 0) {
// No idle handlers to run. Loop and wait some more.
mBlocked = true;
continue;
}
if (mPendingIdleHandlers == null) {
mPendingIdleHandlers = new IdleHandler[Math.max(pendingIdleHandlerCount, 4)];
}
mPendingIdleHandlers = mIdleHandlers.toArray(mPendingIdleHandlers);
}
// Run the idle handlers.
// We only ever reach this code block during the first iteration.
for (int i = 0; i < pendingIdleHandlerCount; i++) {
final IdleHandler idler = mPendingIdleHandlers[i];
mPendingIdleHandlers[i] = null; // release the reference to the handler
boolean keep = false;
try {
keep = idler.queueIdle();
} catch (Throwable t) {
Log.wtf(TAG, "IdleHandler threw exception", t);
}
if (!keep) {
synchronized (this) {
mIdleHandlers.remove(idler);
}
}
}
// Reset the idle handler count to 0 so we do not run them again.
pendingIdleHandlerCount = 0;
// While calling an idle handler, a new message could have been delivered
// so go back and look again for a pending message without waiting.
nextPollTimeoutMillis = 0;
}
}当调用了next得到了一个消息之后，将会调用msg.target.dispatchMessage方法。在Message的分析中知道了target就是Handler，下面看Handler的dispatchMessage方法：
public void dispatchMessage(Message msg) {
//如果Message的Callback不为null，即通过postXXX方法发出的消息
if (msg.callback != null) {
handleCallback(msg);
} else {
//如果Handler的mCallback参数不为null，创建Handler时指定
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
//否则调用该方法
handleMessage(msg);
}
}从上面的代码可以看到几种情况，
- 如果Message的callback不为null，那么调用handleCallback方法
- 如果Message的callback为null，且Handler的mCallback不为null，那么调用接口的handleMessage方法，相当于拦截器的作用
- 否则，调用Handler自己的handleMessage方法
下面首先看handleCallback处理带有Runnbale的Message,
private static void handleCallback(Message message) {
message.callback.run();
}从代码中可以看到就是调用Runnbale的run方法，此时，需要注意的是，这个任务是在Handler关联的线程中执行的；如果Handler是主线程的，那么这个Runnnbale就是在主线程，也就可以进行更新UI操作；如果不是，那么一定不能更新UI。
下面再看handleMessage方法，代码如下：
/**
* Subclasses must implement this to receive messages.
*/
public void handleMessage(Message msg) {
}handleMessage是一个空实现，这也就是子类为什么需要重写该方法的原因，重写该方法，才能真正处理消息。
删除消息
Handler不止可以发出消息，还可以对已经发出且未执行的消息进行取消。可以调用removeXXX方法，有如下方法：
public final void removeCallbacks(Runnable r)
{
mQueue.removeMessages(this, r, null);
}
public final void removeCallbacks(Runnable r, Object token)
{
mQueue.removeMessages(this, r, token);
}
public final void removeMessages(int what) {
mQueue.removeMessages(this, what, null);
}
public final void removeMessages(int what, Object object) {
mQueue.removeMessages(this, what, object);
}
public final void removeCallbacksAndMessages(Object token) {
mQueue.removeCallbacksAndMessages(this, token);
}主要有上面五个方法，可以分别用于删除提交的任务，what字段等；而最终都是调用MessageQueue的removeMessages方法，下面是其实现：
void removeMessages(Handler h, int what, Object object) {
if (h == null) {
return;
}
synchronized (this) {
Message p = mMessages;
// Remove all messages at front.
while (p != null && p.target == h && p.what == what
&& (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 && n.what == what
&& (object == null || n.obj == object)) {
Message nn = n.next;
n.recycleUnchecked();
p.next = nn;
continue;
}
}
p = n;
}
}
}从上面的代码可以看出，主要根据Handler、what和object三个字段判断一个消息是否应该被移出队列，只有当三个条件都满足时，才会将消息移出队列。
如何退出消息循环？
前面的分析中一旦调用了loop方法后，就进入了一个死循环，这也意味着创建Looper的那个线程一直运行着，那么如何退出消息循环呢？
退出循环，可以调用Looper的quit和quitSafely方法，如下：
public void quit() {
mQueue.quit(false);
}
public void quitSafely() {
mQueue.quit(true);
}quit和quitSafely方法的区别在于：
- quit方法不会再执行消息队列中的任何消息
- quitSafely方法会执行消息队列中的消息；但是对于执行时间超过当前时间消息，则删除。
下面是MessageQueue的quit方法：
void quit(boolean safe) {
if (!mQuitAllowed) {
throw new IllegalStateException("Main thread not allowed to quit.");
}
synchronized (this) {
if (mQuitting) {
return;
}
mQuitting = true;
//安全退出
if (safe) {
removeAllFutureMessagesLocked();
} else {
removeAllMessagesLocked();
}
// We can assume mPtr != 0 because mQuitting was previously false.
nativeWake(mPtr);
}
}可以看到如果是安全退出，那么会调用removeAllFutureMessagesLocked方法，否则调用removeAllMessageLocked方法，首先看removeAllMessagesLocked方法删除所有消息：
private void removeAllMessagesLocked() {
Message p = mMessages;
while (p != null) {
Message n = p.next;
p.recycleUnchecked();
p = n;
}
mMessages = null;
}从代码可以看到，主要就是遍历队列，将每一个消息回收进消息对象池中，清空队列。
下面再看安全退出的情况：
private void removeAllFutureMessagesLocked() {
final long now = SystemClock.uptimeMillis();
Message p = mMessages;
//队列不为空
if (p != null) {
//如果队头时间比当前时间大，则说明所有时间都是延迟的，那么全部删除
if (p.when > now) {
removeAllMessagesLocked();
}
//一部分消息需要执行，一部分消息时间比较迟
else {
Message n;
//找出大于当前时间的那个节点
for (;;) {
n = p.next;
if (n == null) {
return;
}
if (n.when > now) {
break;
}
p = n;
}
//删除后部分节点
p.next = null;
do {
p = n;
n = p.next;
p.recycleUnchecked();
} while (n != null);
}
}
}从上面的代码可以看到安全退出的处理逻辑，如果消息都是延迟的，那么全部删除；如果有不是延迟的，那么留给loop方法继续取出。
总结
从上面的分析，我们知道了Handler控制MessageQueue的消息入队，Looper负责轮询MessageQueue，一旦发现需要执行的Message，就根据其target字段分开给发送的Handler，而分发就是dispatchMessage方法，Handler可以重写handleMessage来处理得到的消息。
本文中代码请见我的Github