View#post和Handler#post

注:本文提到的调用Handler#post,其Handler对象都指的是用UI主线程的Looper创建的Handler对象。

View#post方法的实现跟版本有关,具体为:

  1. API level 24(Android7.0)及以上:
    public boolean post(Runnable action) {
        final AttachInfo attachInfo = mAttachInfo;
        if (attachInfo != null) {
            return attachInfo.mHandler.post(action);
        }

        // Postpone the runnable until we know on which thread it needs to run.
        // Assume that the runnable will be successfully placed after attach.
        getRunQueue().post(action);
        return true;
    }
  1. API level 23及以下:
    public boolean post(Runnable action) {
        final AttachInfo attachInfo = mAttachInfo;
        if (attachInfo != null) {
            return attachInfo.mHandler.post(action);
        }
        // Assume that post will succeed later
        ViewRootImpl.getRunQueue().post(action);
        return true;
    }

由上可知,两种版本,当attachInfo不为空时,实现是一样的,都是调用attachInfo的Handler对象,往UI主线程的MessageQueue中扔Runnable,这和直接调用Handler#post的效果一样。

当attachInfo为空时,就得分版本来分析了:

  1. 7.0及其以上是:往HandlerActionQueue中扔Runnable。具体实现为:
    首先,调用getRunQueue()获得HandlerActionQueue对象,获取过程很简单,看HandlerActionQueue对象有没有,有就直接返回,没有就new一个再返回。
    private HandlerActionQueue getRunQueue() {
        if (mRunQueue == null) {
            mRunQueue = new HandlerActionQueue();
        }
        return mRunQueue;
    }

然后,调用HandlerActionQueue对象的post方法,再调postDelayed方法(delay 0毫秒),将Runnable对象封装成HandlerAction对象再扔进队列里:

public class HandlerActionQueue {
    private HandlerAction[] mActions;
    private int mCount;

    public void post(Runnable action) {
        postDelayed(action, 0);
    }

    public void postDelayed(Runnable action, long delayMillis) {
        // 将Runnable封装成HandlerAction对象
        final HandlerAction handlerAction = new HandlerAction(action, delayMillis);

        synchronized (this) {
            if (mActions == null) {
                mActions = new HandlerAction[4];
            }
            mActions = GrowingArrayUtils.append(mActions, mCount, handlerAction);
            mCount++;
        }
    }
    //省略其他代码
    ......
}
  1. 7.0以下是:通过ViewRootImpl获取到的RunQueue,然后往这个队列中扔Runnable。具体实现为:
public final class ViewRootImpl implements ViewParent,
        View.AttachInfo.Callbacks, HardwareRenderer.HardwareDrawCallbacks {
//省略代码
...
    static final ThreadLocal sRunQueues = new ThreadLocal();

//省略代码
...

    static RunQueue getRunQueue() {
        RunQueue rq = sRunQueues.get();
        if (rq != null) {
            return rq;
        }
        rq = new RunQueue();
        sRunQueues.set(rq);
        return rq;
    }

//省略代码
...
}

可以发现两个版本主要的不同点在队列对象上。
7.0以下的版本,队列是从一个ThreadLocal对象里面获取到的,也就是说,不同的线程会获取到不同的RunQueue队列对象,且在同一个线程里,队列对象是共享的,大家用一个。
而7.0及以上版本,不管在什么线程里,获取的都是同一个HandlerActionQueue队列对象,且队列对象是属于View实例自己的,自己用自己的,不共享。

再回顾下,AttachInfo为空时,会先将Runnable缓存在一个队列(队列对象在Android7.0版本前后不同)里面,那么什么时候把缓存在队列中的Runnable取出来呢?

答案在ViewRootImpl#performTraversals方法中。

  1. 7.0及以上:调用了host的dispatchAttachedToWindow方法,这个host就是DecorView对象。
    private void performTraversals() {
        //省略代码
        ...

        if (mFirst) {
            //省略代码
            ...
     
            host.dispatchAttachedToWindow(mAttachInfo, 0);
           //省略代码
           ...
        } else {
           //省略代码
           ...
        }
        //省略代码
        ...
}

在DecorView和其父类FrameLayout中都没有重写dispatchAttachedToWindow方法,于是直接去ViewGroup中找dispatchAttachedToWindow的方法实现:

    void dispatchAttachedToWindow(AttachInfo info, int visibility) {
        mGroupFlags |= FLAG_PREVENT_DISPATCH_ATTACHED_TO_WINDOW;
        super.dispatchAttachedToWindow(info, visibility); //首先,调View的dispatchAttachedToWindow,即通知自身AttachedToWindow
        mGroupFlags &= ~FLAG_PREVENT_DISPATCH_ATTACHED_TO_WINDOW;

        final int count = mChildrenCount;
        final View[] children = mChildren;
        for (int i = 0; i < count; i++) {
            final View child = children[i];
            child.dispatchAttachedToWindow(info,
                    combineVisibility(visibility, child.getVisibility())); //然后,调子View的dispatchAttachedToWindow,通知子View AttachedToWindow
        }
        final int transientCount = mTransientIndices == null ? 0 : mTransientIndices.size();
        for (int i = 0; i < transientCount; ++i) {
            View view = mTransientViews.get(i);
            view.dispatchAttachedToWindow(info,
                    combineVisibility(visibility, view.getVisibility()));
        }
    }

这样,从父View到子View,通过深度优先遍历,将AttachToWindow这个事儿传遍View树。
在View的dispatchAttachedToWindow中,终于将缓存在RunQueue中的Runnable取出来了,通过AttachInfo的Handler扔到UI线程的MessageQueue中,等待被执行。

    void dispatchAttachedToWindow(AttachInfo info, int visibility) {
         //省略代码
        ...
        // Transfer all pending runnables.
        if (mRunQueue != null) {
            mRunQueue.executeActions(info.mHandler);
            mRunQueue = null;
        }
        //省略代码
        ...
    }
  1. 7.0以下,通过之前的分析我们知道,那个缓存队列是通过ViewRootImpl的一个静态方法getRunQueue()去获取的。这里同样调用getRunQueue()方法获取对应线程的缓存队列,然后调用executeActions()方法将缓存在队列中的Runnable取出来,最后同样是通过AttachInfo的Handler往主线程的MessageQueue中扔:
    private void performTraversals() {
        //省略代码
        ...
        // Execute enqueued actions on every traversal in case a detached view enqueued an action
        getRunQueue().executeActions(mAttachInfo.mHandler);

基于AttachInfo为空这个大前提下,值得注意的一点是,如果是在子线程调用的View#post,那么Runnable是往子线程的缓存队列里扔的,而ViewRootImpl#performTraversals是在主线程中被执行的,
getRunQueue()取的是主线程对应的缓存队列,这是两个不同的缓存队列实例,因此Runnable当然不会被执行了。

总结

  1. 如果view已经attach到window了,那么View#post和Handler#post作用一样,都是往调用UI主线程的MessageQueue中扔Runnable。
  2. 如果view还未attach到window中,则需要通过一个缓存队列将Runnable暂时先缓存起来,等到view attach到window上之后,再将缓存队列中的Runnable取出来,再扔到UI线程的MessageQueue中,此时:
  • 如果是在主线程调用的View#post,那么在各个Android版本上都没问题,都会在ViewRootImpl的下一次performTraversal()是被执行;
  • 如果是在非主线程调用的View#post,就得分版本考虑:
    1)如果是在Android7.0及以上版本,没毛病。缓存队列用的是各个View对象实例自己的,跟线程没关系,通过ViewRootImpl#performTraversal方法,最后会把各个View的缓存队列中的Runnable都扔到主线程消息队列MessageQueue中,等待被执行。
    2)如果是在Android7.0以下版本,就悲剧了。缓存队列是从ViewRootImpl中的一个ThreadLocal静态变量里获取的,各个线程取到的是不同的RunQueue对象实例,子线程是往子线程自己的RunQueue队列中扔Runnable,ViewRootImpl#performTraversal是在主线程中被执行,取的是主线程的RunQueue队列,于是你在子线程post的Runnable就没法被执行了。

reference: 两者区别

你可能感兴趣的:(View#post和Handler#post)