一、还是先明确下主题：
通过追踪源码，分析调用runOnUiThread（runnable）后，Android系统最终如何在主线程中运行runnable中的代码的，聊聊这中间的过程发生了什么。如果你已经明白了下面的问题：
- Handler通过sendMessage ()将message对象通过enqueueMessage()插入到MessageQueue中
- Looper通过loop()死循环，不断通过MessageQueue.next()取得Message
- 再利用Handler的dispatchMessage()将message分发到对应的target Handler
- MessageQueue中enqueueMessage()方法涉及到同步问题
- MessageQueue中next()方法可能会block
- Message本质是一个保存有next引用的链表节点
- MessageQueue的消息队列是通过链表实现的，这个链表是按照时间排序的
- MessageQueue保存了一个message，这个message是消息队列链表的头节点
- loop()的死循环是运行在主线程的，且随ActivityThread中的main()方法启动的
- 最后，还用过Looper.myQueue.addIdleHandler()方法向主线程发送一个未设置延迟时间的延迟消息，当然它未必延迟运行，取决于MessageQueue是不是闲着没事儿干了。
那么，恭喜你，还是不要浪费你的时间了，你已经都会了。。。
如果，还有些问题不明确，我们下面一起来聊聊，为什么是聊聊，因为我不是权威哈，说的不对还需要读者指正呢。
二、源码分析过程
这里我们会把Handler、Message、MessageQueue、Looper中的关键源码贴出来，action！
- 建立demo，子线程通过runOnUiThread()更新TextView:
new Thread(new Runnable() {
@Override
public void run() {
spentLittleTime();//子线程耗时操作
runOnUiThread(new Runnable() {
@Override
public void run() {
mTextView.setText("Hello world");
}
});
}
}).start();
- activity中runOnUiThread方法：
public final void runOnUiThread(Runnable action) {
if (Thread.currentThread() != mUiThread) {//当前非主线程
mHandler.post(action);
} else {
action.run();
}
}
我们现在进入Handler源码中了
- 如果当前是主线程，则马上执行run方法，否则交由activity的成员变量mHandler.post()处理:
public final boolean post(Runnable r) {
//实际调用sendMessageDelayed
return sendMessageDelayed(getPostMessage(r), 0);
}
private static Message getPostMessage(Runnable r) {
//Message.obtain()是享元模式，说明推荐不要用new Message()
Message m = Message.obtain();
m.callback = r;
return m;
}
还记得handler.postDelayed(Runnable r, long delayMillis)方法吧，能够实现延迟指定时间后运行，实际上post和postDelayed两个方法最终调用的都是sendMessageDelayed，继续调用sendMessageAtTime，只不过post把延迟时间默认设为0而已。
public final boolean sendMessageDelayed(Message msg, long delayMillis)
{
if (delayMillis < 0) {
delayMillis = 0;
}
//注意SystemClock.uptimeMillis()这个方法
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);
}
在sendMessageAtTime方法中涉及到SystemClock.uptimeMillis()，这个方法需要注意一下，它是native方法，其返回的是开机到现在的时间，但并不包含CPU休眠、屏幕休眠的时间。另外，还有postAtTime(Runnable r, long uptimeMillis), 其uptimeMillis参数也是如此。
5、 终于到了enqueueMessage方法
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
msg.target = this;
if (mAsynchronous) {
msg.setAsynchronous(true);
}
return queue.enqueueMessage(msg, uptimeMillis);
}
这里用到了MessageQueue，在handler的构造方法中进行了初始化操作：
public Handler(Callback callback, boolean async) {
...
mLooper = Looper.myLooper();//获取当前线程的looper
...
mQueue = mLooper.mQueue;//MessageQueue作为looper的成员变量，在Looper的构造方法中被初始化
...
}
关于handler，这个过程中关键源码就这些了
下面直接进入MessageQueue了
6、在MessageQueue主要是两个方法：enqueueMessage()、next()：
boolean enqueueMessage(Message msg, long when) {
...
synchronized (this) {//线程同步的问题
...
msg.markInUse();
msg.when = when;
Message p = mMessages;
boolean needWake;
//when==0，还记得上面我们提到handler.post()默认
//指定延迟时间为0吗,插入到队列链表的头节点
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;
//when < p.when可以看出链表以时间排序
if (p == null || when < p.when) {
break;
}
if (needWake && p.isAsynchronous()) {
needWake = false;
}
}
//将msg插入到这个以时间排序的列表的指定位置
msg.next = p; // invariant: p == prev.next
prev.next = msg;
}
...
}
return true;
}
到现在为止，我们已经看到已经成功把message插入到了MessageQueue的链表里了，暂且不谈MessageQueue.next()方法，因为MessageQueue.next()是从链表中取message的操作
这样我们就要先从Looper聊起了
7、因为Looper就负责不断从MessageQueue中取Message了，那Looper是如何被运行起来的呢？首先要有一个不断循环的逻辑吧：
public static void loop() {
final Looper me = myLooper();
final MessageQueue queue = me.mQueue;
...
for (;;) {
Message msg = queue.next(); // 可能block，后面再聊
if (msg == null) {
return;
}
...
msg.target.dispatchMessage(msg);//分发到对应的handler
...
}
}
loop通过for不断循环，将取到的message分发到对应的handler，那么问题来了，对于主线程中的Looper.loop()是在哪里被调用的？或者说这个死循环是怎么开始的？
8、答案就是在ActivityThread类中的main()方法中：
public static void main(String[] args) {//熟不熟悉，Java程序入口
...
Looper.prepareMainLooper();//准备好要干活了
ActivityThread thread = new ActivityThread();
thread.attach(false);
if (sMainThreadHandler == null) {
//此sMainThreadHandler将会在activity的启动过程中用到
//其继承自Handler
//作为ActivityThread的内部类包含了LAUNCH_ACTIVITY等关键字段
sMainThreadHandler = thread.getHandler();
}
Looper.loop();//开始干活了
...
}
prepareMainLooper()主要是调用了Looper.prepare()方法：
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));
}
并且应用了ThreadLocal保存了Looper对象，ThreadLocal的好处在于让线程维护自己的looper对象，一个线程中调用Looper.myLooper()保证获取到的looper是正确的：
public static @Nullable Looper myLooper() {
return sThreadLocal.get();
}
9、回到loop()方法吧，那里还有一个MessageQueue.next()方法，很关键的一步：
Message next() {
...
int pendingIdleHandlerCount = -1;
int nextPollTimeoutMillis = 0;
for (;;) {
nativePollOnce(ptr, nextPollTimeoutMillis);
synchronized (this) {
final long now = SystemClock.uptimeMillis();
Message prevMsg = null;
Message msg = mMessages;
if (msg != null && msg.target == null) {
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 {
//找到了一个需要执行的msg
mBlocked = false;
if (prevMsg != null) {
prevMsg.next = msg.next;
} else {
mMessages = msg.next;
}
msg.next = null;
msg.markInUse();//标记为已经使用
return msg;//返回给Looper.loop()方法
}
} else {
nextPollTimeoutMillis = -1;
}
if (pendingIdleHandlerCount < 0
&& (mMessages == null || now < mMessages.when)) {
pendingIdleHandlerCount = mIdleHandlers.size();
}
if (pendingIdleHandlerCount <= 0) {
mBlocked = true;
continue;
}
mPendingIdleHandlers = mIdleHandlers.toArray(mPendingIdleHandlers);
}
for (int i = 0; i < pendingIdleHandlerCount; i++) {
final IdleHandler idler = mPendingIdleHandlers[i];
mPendingIdleHandlers[i] = null;
boolean keep = false;
keep = idler.queueIdle();//空闲时候要执行的事件
if (!keep) {
synchronized (this) {
mIdleHandlers.remove(idler);
}
}
}
pendingIdleHandlerCount = 0;
nextPollTimeoutMillis = 0;
}
}
10、关于IdleHandler，当消息队列中没有其他要处理的消息时，将处理以上代码中通过addIdleHandler添加的Idler对象，也就是说，Idler对象的优先级最低。在项目中使用方式：
Looper.myQueue().addIdleHandler(new IdleHandler()
{
@Override
public boolean queueIdle()
{
//你想做的事情
...
return false;
}
});
11、终于要接近尾声了，手打字都好累，loop中取到了Message对象，通过handler.dispatchMessage()进行分发：
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg);//实际是msg.callback.run();
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}
handleCallback(msg)实际就是msg.callback.run()，而这里的callback就是runOnUiThread()的参数runnable对象，继续看到handleMessage()方法了没,如果我们在项目中不是采用runOnUiThread()而是采用new Handler()方式更新UI，那么我们就自己重载handleMessage()了，runOnUiThread()实质还是利用handler了。
三、最后，总结
没了，我觉得能看到这儿的朋友是真爱，总结就是开头的10个问题，翻回去看吧。
再见。。。有错误欢迎指正，此致那个敬礼，我该回家了：
2016年10月26日23:15:12。