Handler的一点分析
Handler算是android的重要角色了。在APP的开发中经常使用到它。他的用法很多，相信大家也熟悉，这里就不废话了。这次主要从源码的角度来说说我对他的一些理解，希望能帮到正在阅读的你。
从外部看Handler
正常使用Handler无外乎两个场合，一个就是在主线程中，一个就是在自己开的非主线程中。
如果在主线程中的话，Handler的使用时这样的
Handler mHandler = new Handler() {
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case 123:
//do something
}
}
};
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
Message message = Message.obtain();
message.what = 123;
mHandler.sendMessage(message);
只需要复写handleMessage方法，然后sendMessage，就会调用自己复写的handleMessage方法，通过判断what来处理对应的message事件。那么，系统到底做了哪些事情，使得这一切路逻辑成立的？？？
先别急，我们再来看看在非主线程中Handler是怎么用的
new Thread() {
@Override
public void run() {
Looper.prepare();
Handler handler = new Handler() {
@Override
public void handleMessage(Message msg) {
Log.e("Totoro", "handleMessage: ");
}
};
handler.sendEmptyMessageDelayed(1, 0);
handler.sendEmptyMessageDelayed(2, 1000);
handler.getLooper().quitSafely();
Looper.loop();
}
}.start();
看起来比主线程要麻烦一些了
我们一步一步来分析
1.Looper.prepare()
这里注意，如果在子线程中想要创建Handler的话，那就必须先要调用Looper.prepare()，不然的的话
java.lang.RuntimeException: Can't create handler inside thread that has not called Looper.prepare()
打开Looper.prepare()的源代码来看看
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.set(new Looper(quitAllowed));。sThreadLocal其实就是一个Map容器，set了一个Looper对象。可以理解为创建了一个Loopr并且保存起来了。我们来看看Looper的构造方法
private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}
在Looper对象的构造器中指定Thread为当前线程。这就意味着Looper是依赖于当前线程的。同时创建了一个MessageQueue的对象。MessageQueue又是什么？？？？单看名字好像是消息队列。看看他的构造方法
MessageQueue(boolean quitAllowed) {
mQuitAllowed = quitAllowed;
mPtr = nativeInit();
}
说来惭愧，我不知道mPtr是干嘛的，也不知道 nativeInit()做了什么，他是个native方法。能力有限，抱歉。不过这不影响我们继续学习。MessageQueue里面做了一些初始化，先知道这么多就好。
总结一下就是，Looper.prepare()方法创建了Looper的对象并且保存在了特定的容器里面，Looper对象里面又包含了一个MessageQueue对象。为之后的工作做好了准备。
2. Handler handler = new Handler()
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;
}
Handler有很多构造方法，不论你调用该哪个最后都会调用到这个构造方法。
可以看到，Handler里面是包含了Looper和MessageQueue的，MessageQueue来自Looper。所以一个Handler对应唯一的Looper和唯一的MessageQueue。Looper的赋值是Looper.myLooper()方法，打开看看
public static @Nullable Looper myLooper() {
return sThreadLocal.get();
}
这就对上了，之前sThreadLocal时调用了set方法存进去的，这会再取出。
3.sendMessage
之前的两步都是准备工作。现在正式发出消息。
handler有很多方法可以发出消息。sendMessage(Message msg)，sendEmptyMessageDelayed(int what, long delayMillis)等等。他们最后都是一个去向。
这里以sendEmptyMessageDelayed为例
public final boolean sendEmptyMessageDelayed(int what, long delayMillis) {
Message msg = Message.obtain();
msg.what = what;
return sendMessageDelayed(msg, delayMillis);
}
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) {
msg.target = this;
if (mAsynchronous) {
msg.setAsynchronous(true);
}
return queue.enqueueMessage(msg, uptimeMillis);
}
可以看到，连续经过了4个方法。也都简单。主要就是把msg的what和target赋值。
这里要注意下，Message这个类之前一直没说。后面还会再讲到它。现在这里他的what是我们传入的参数，他是message的一个标志，一般都用它来区分不同的message。target是this，这些方法都是在Handler里面的，所以target是message所对应的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) {
// 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;
}
// We can assume mPtr != 0 because mQuitting is false.
if (needWake) {
nativeWake(mPtr);
}
}
return true;
}
这里代码有点多，我们看主要的就好。
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;
}
先找到这里，mMessage这个数据域在第一次调用的时候是null。如果你学过数据结构的话，这个代码你看着可能比较眼熟。没错，他就是单链表的头插法！mMessage最后会成为表头节点。Mesage这个类的构成有一个数据域，是Message next;也就是说Message本身就是单链表结构的。一个正常的节点进来折后，通过if判断被插入到最开头。
还有一个对应的else
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;
prev.next = msg;
依旧看着比较眼熟，单链表的插入操作。到这的话，MessageQueue的enqueueMessage方法就比较清楚了，他是用来构建单链表的，链表的每个节点都是Message。而每个节点是通过对时序来决定它在链表的中位置，看看是直接插在表头还是插在中间。
可以看到MessageQueue这个类并不是自己是个队列，而是组织Message成为一个单链表的队列。也就是按照时间排序好的消息队列。
这个方法就是这里的终结了。
4.Looper.loop()
等等，之前不是还有个 handler.getLooper().quitSafely()的吗？？？怎么跳过了？？？是这样的，先讲Looper.loop()再说quitSafely()更加清楚。所以等会再说。
消息队列现在已经形成，怎么处理这些？？这里就是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 slowDispatchThresholdMs = me.mSlowDispatchThresholdMs;
final long traceTag = me.mTraceTag;
if (traceTag != 0 && Trace.isTagEnabled(traceTag)) {
Trace.traceBegin(traceTag, msg.target.getTraceName(msg));
}
final long start = (slowDispatchThresholdMs == 0) ? 0 : SystemClock.uptimeMillis();
final long end;
try {
msg.target.dispatchMessage(msg);
end = (slowDispatchThresholdMs == 0) ? 0 : SystemClock.uptimeMillis();
} finally {
if (traceTag != 0) {
Trace.traceEnd(traceTag);
}
}
if (slowDispatchThresholdMs > 0) {
final long time = end - start;
if (time > slowDispatchThresholdMs) {
Slog.w(TAG, "Dispatch took " + time + "ms on "
+ Thread.currentThread().getName() + ", h=" +
msg.target + " cb=" + msg.callback + " msg=" + msg.what);
}
}
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();
}
}
依然好长，我们还是看主要的
可以看到，没走几步直接进了死循环 for (;;)
这里就是重点
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 {
......
}
......
msg.recycleUnchecked();
}
这些事主要的代码。这里queue就是Looper内置的MessageQueue，前面说过了。他调用了next方法。我们来看看
Message next() {
......
for (;;) {
......
synchronized (this) {
// Try to retrieve the next message. Return if found.
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) {
// Next message is not ready. Set a timeout to wake up when it is ready.
nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);
} else {
// Got a message.
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;
}
}
......
if (mQuitting) {
dispose();
return null;
}
......
}
}
只是主要代码。可以看到，又是个死循环。(╯‵□′)╯︵┻━┻。
不过这个循环很容易就跳出去了。mMessage之前说过了是表头结点，msg刚开始就是表头节点。然后是第一个if
if (msg != null && msg.target == null)
这里一般情况判断都是不成立的。还记得之前sendMessage的时候吗，target普遍都是被赋值了的，就是对应的handler，一般不为null。所以进入第二个if
if (msg != null)
如果消息队列不空的话，这个条件肯定就成立了。里面是删除表头结点，并且把删除的这个及诶单反回了。这就是所谓的next()方法，很是符合，返回了头结点。
还有一个情况也可以跳出去，就是 if (mQuitting){}，这个之后再说。
回到前面，从queue里取出了要处理的message之后，做了一个判断，就是这个message是不是null。这其实是loop方法死循环的出口，我们后面再说。就假设我们消息队列里面有好多消息，不为null。这里就进入到了msg.target.dispatchMessage(msg);方法了。msg的target就是对应的handler，所以这里是调用了handler的dispatchMessage方法，打开看看
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}
这里先是想要调用message的callback。这东西和post方法有关，后面说。我们没有设置msg的callback，所以进入else，mCallback又没有设置。。。。。。
所以最后进入了handleMessage(msg)
等等！！！！！！！
这不就是我们覆写的那个方法吗！！！
到这，handler传递处理消息的过程就结束了。
quitSafely()和quit()
前面已经看到了，loop方法用于处理消息队列里面的消息，他是一个死循环，如果调用queue的next()方法得到的msg为null的话，就会终止。这看上去很合理，但是。。。。。。
大家可以试试，不发送任何message，创建好handler直接loop，会直接卡在loop不动了。
不太对啊，MessageQueue维护了一个单链表，单链表的最后不就是null吗，按理说不断地调用next方法，应该会送回null才对
但是就是卡死了。。。。
这是为啥？？ (ÒωÓױ)！
debug了一下，发现，如果不发送任何message，MessageQueue是空的话，会发生这样的事
next()方法也是个死循环这个大家还没忘吧，如果链表是个空的，那么里面的判断条件就都不成立了，于是就跳不出去，还执行了这个
nextPollTimeoutMillis = -1;
然后开始执行第二次循环，第二次循环开始的时候又会执行这个
nativePollOnce(ptr, nextPollTimeoutMillis);
只怪我学识浅薄，这又是个native方法，我看不懂。。。。。它的第二个参数是别的都好好的，唯独是-1的时候，就一去不返了。第一次循环又把它置为-1了，所以代码到这就卡死了。所以loop也就同时卡死了。
(╯‵□′)╯︵┻━┻
那咋办？？？？
其实想想，只要能在next方法中返回null，loop自然就结束了。还记得next中那个没说的 if (mQuitting)吗。这里如果能把它置为true的话，自然就可以终止了。而事实上，终止正是用了这个逻辑
这个逻辑就写在MessageQueue的quit方法中，不过我们需要调用Looper的quit或者quitSafely()来间接调用
public void quit() {
mQueue.quit(false);
}
public void quitSafely() {
mQueue.quit(true);
}
不同之处在于参数一个是true，一个是false
我们打开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);
}
}
这下清楚了，mQuitting就是在这里面被置为true的。
还有就是true和false执行了不同的逻辑，再来看看
先说removeAllMessagesLocked()
private void removeAllMessagesLocked() {
Message p = mMessages;
while (p != null) {
Message n = p.next;
p.recycleUnchecked();
p = n;
}
mMessages = null;
}
Message的recycleUnchecked()方法就是清零message用的。这个代码一目了然，销毁单链表。如果单链表被销毁，mMessage就是null，那么next方法中前面的判断都不成立，mQuitting又是true了，走到mQuitting那个if那里，就会返回null了。loop就会终止。
这里你可能会问，整个链表都没了？？那岂不是为了终止loop，什么都处理不了了吗？？事实上是这样的
所以还有这个removeAllFutureMessagesLocked()
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);
}
}
}
这个方法就可能不销毁链表了，同时mQuitting之前也被置为true了，在链表都遍历结束之后，再次走到mQuitting那个if那里，返回null，loop就结束了，并且消息全部都得到了处理。
不过有一点要注意就是Looper的quit()和quitSafely方法要在loop之前调用，不然loop调用之后，mQuitting还是false，退不出来。
到这里，在非主线程中创建和使用handler的代码就全部说完了。
关于post
其实post一系列方法也是sendMessage。
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;
}
它就是把我们传进来的runnable对象赋给message的callback了。
还记得dispatchMessage那个方法吗，上来是先判断message的callback的，这里我们设置了callback，就会调用这个，不会再调用handlrMessage了。
总结
整个Hnadler的消息传递，就是handler发出消息，进入到MessageQueue，然后loop不断循环，取出MessageQueue的消息，反馈到handler中处理。
现在想想在主线程中使用handler为什么直接sendMessage就可以了？？原因就是主线程把一切工作都做好，什么loop，quit，都不用管。
文章很长，谢谢你读到这里，能帮到你的话不胜荣幸！
