Android源码 从runOnUiThread聊聊消息机制

一、还是先明确下主题：

  通过追踪源码，分析调用runOnUiThread（runnable）后，Android系统最终如何在主线程中运行runnable中的代码的，聊聊这中间的过程发生了什么。如果你已经明白了下面的问题：
1. Handler通过sendMessage ()将message对象通过enqueueMessage()插入到MessageQueue中
2. Looper通过loop()死循环，不断通过MessageQueue.next()取得Message
3. 再利用Handler的dispatchMessage()将message分发到对应的target Handler
4. MessageQueue中enqueueMessage()方法涉及到同步问题
5. MessageQueue中next()方法可能会block
6. Message本质是一个保存有next引用的链表节点
7. MessageQueue的消息队列是通过链表实现的，这个链表是按照时间排序的
8. MessageQueue保存了一个message，这个message是消息队列链表的头节点
9. loop()的死循环是运行在主线程的，且随ActivityThread中的main()方法启动的
10. 最后，还用过Looper.myQueue.addIdleHandler()方法向主线程发送一个未设置延迟时间的延迟消息，当然它未必延迟运行，取决于MessageQueue是不是闲着没事儿干了。

那么，恭喜你，还是不要浪费你的时间了，你已经都会了。。。
如果，还有些问题不明确，我们下面一起来聊聊，为什么是聊聊，因为我不是权威哈，说的不对还需要读者指正呢。

二、源码分析过程

这里我们会把Handler、Message、MessageQueue、Looper中的关键源码贴出来，action！
1. 建立demo，子线程通过runOnUiThread()更新TextView:

new Thread(new Runnable() {
            @Override
            public void run() {
                spentLittleTime();//子线程耗时操作
                runOnUiThread(new Runnable() {
                    @Override
                    public void run() {
                        mTextView.setText("Hello world");
                    }
                });
            }
        }).start();

1. activity中runOnUiThread方法：

    public final void runOnUiThread(Runnable action) {
        if (Thread.currentThread() != mUiThread) {//当前非主线程
            mHandler.post(action);
        } else {
            action.run();
        }
    }

我们现在进入Handler源码中了

1. 如果当前是主线程，则马上执行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而已。
4.

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。