Handler源码解析
刚入行Android那会，看过好多遍这方面的不同的博客，每次看完都似懂非懂，今天我打算自己来分析一下Handler机制及其相关源码。
主要涉及以下几个类：
- Handler
- MessageQueue
- Looper
- Message
看一下官方对Handler这个类的解释：Handler允许你向其发送Message或者是post Runnable，一个Handler只能绑定一个线程以及线程对应的MessageQueue。当我们创建一个新的Handler的时候，它就和创造它的时候所在的线程以及线程对应的MessageQueue绑定了，它将用来将messages和runnables传送给MessageQueue，以及执行他们当他们从MessageQueue队列中被pop出来的时候。
Handler有两种用处：一是用来执行同一线程中的messages以及runnables，二是在另一个线程中执行。
发送消息的方式有很多种，主要是由以下方法来完成的：
一类是post runnable
post
postAtTime
postDelayed
一类是send message
sendEmptyMessage
sendMessage
sendMessageAtTime
sendMessageDelayed
这些方法能够让你控制是现在执行，还是需要延迟多长时间来执行。
当我们开启一个应用时，即开启了一个进程，应用的主线程就会开启一个MessageQueue队列用来管理最重要的一些对象，如Activity和广播，你可以创建一个子线程，通过Handler来与主线程或者应用来进行通信，当合适的时候，这些runnable或者message会被执行。
通过大概翻译官方注释，我们可以发现Handler主要是用来做线程间通信的，分析Handler我们主要分析上面提到的两类方法：1.post runnable 2.send message
我们先分析send 系列方法：
通过查看源码，我们可以发现，不论是sendMessage，还是sendMessageDelayed还是sendEmptyMessage，最终都会调用sendMessageAtTime方法。这里面涉及到一个Message对象，我们稍后来分析，最终会走到enqueueMessage方法，enqueueMessage方法会走到MessageQueue里面的enqueueMassage。待会我们一起分析。
我们再来看post runnable系列方法：
通过查看源码，我们可以发现，最终也是走到sendMessageAtTime方法，然后调用enqueueMessage。只不过，在这个过程中，创建了一个Message实例，并将runnable赋给了message的callback。
Handler我们先分析到这里。
下面我们来分析Message这个类：
Message这个类的数据结构可以说是一个单链表，它有几个重要的成员变量：
- next 指向链表下一item的引用
- what 用来区别是哪一类消息，相当于一个type
- target 用来保存所属Handler的引用
- callback 用来保存要执行的任务runnable
其他还包括arg1，arg2 ，object等，这些就不一一解释了
Message类还有一个重要方法：obtain。
当我们创建一个Message对象时，我们可以new，也可以通过Message.obtain方法来获取一个实例。官方推荐后者，
/**
* Return a new Message instance from the global pool. Allows us to
* avoid allocating new objects in many cases.
*/
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回收池为空的时候才会去new一个Message。那么这个Message回收池是什么时候建立的呢，以及什么时候往里面放对象的呢？我们找到recycleUnchecked这个方法,可以发现这个方法就是将Message的flag置为FLAG_IN_USE，并且清空其他参数，并将其加入到缓存池。这个方法是在MessageQueue执行enqueueMessage的时候才会调用。
下面我们来分析MessageQueue这个类：
首先，看它的构造，除了传了一个参数，其它的都在native处理了，我们也看不见什么，感兴趣的可以去看一下native层代码。
再看一下MessageQueue的数据结构，我们可以发现它其实是一个优先级队列。
队列的插入以及移除item有两个重要方法：
第一个是我么上面提到的enqueueMessage方法：这个方法主要是向队列中插入Message对象：
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 {
//这里是往中间插入,循环链表触发时间,找到对应的插入位置
// 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的next方法,这个方法主要处理的是MessageQueue的出队操作,即从队头开始一个个执行移除.代码太多,就不贴过来了,主要部分就是指针后移:
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;
那么,什么时候才会执行next的方法呢?这就得来到Looper这个类了.
Looper这个类,每个线程都只有一个,跟线程绑定.我们看一下他的主要方法:
public static void loop() {
final Looper me = myLooper();
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);
}
}
msg.recycleUnchecked();
}
}
从上面的代码可以发现,loop差不多就是一个死循环,只有当MessageQueue为空的时候,才会退出.Looper当中有两个重要的地方:
第一个是 Message msg = queue.next(),从队列中取出一个Message,
第二个是 Message msg = queue.next(),这个方法最终会调用message对应handler的dispatchMessage方法
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}
当msg的callback不为空时,执行callback.run,如果为空的话则判断在创建Handler的时候有没有给mCallback赋值,如果有,则走mCallback里面的handleMessage方法,如果没有则走Handler的handleMessage方法.
但是,在实际开发当中,我们发现我们并没有创建Looper,也没有调用Looper的loop方法,为什么也能够执行到我们重写的handleMessage方法呢?
这是因为,我们一般是在主线程即UI线程中创建的Handler,而在主线程中是默认创建了Looper的.看代码:
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");
}
这段代码是截取自ActivityThread的main函数,在我们应用启动的时候,就执行了这个函数.
至此,我们把Handler机制的重要代码都分析完了!!
总结一下:画个图,看懂你就赢了
