注：本文提到的调用Handler#post，其Handler对象都指的是用UI主线程的Looper创建的Handler对象。
View#post方法的实现跟版本有关，具体为：
- 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;
}
- 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为空时，就得分版本来分析了：
- 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++;
}
}
//省略其他代码
......
}
- 7.0以下是：通过ViewRootImpl获取到的RunQueue，然后往这个队列中扔Runnable。具体实现为：
public final class ViewRootImpl implements ViewParent,
View.AttachInfo.Callbacks, HardwareRenderer.HardwareDrawCallbacks {
//省略代码
...
static final ThreadLocal<RunQueue> sRunQueues = new ThreadLocal<RunQueue>();
//省略代码
...
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方法中。
- 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;
}
//省略代码
...
}
- 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当然不会被执行了。
总结：
-
如果view已经attach到window了，那么View#post和Handler#post作用一样，都是往调用UI主线程的MessageQueue中扔Runnable。
-
如果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对象实例，子线程是往子线程自己的RunQueue队列中扔Runnable，ViewRootImpl#performTraversal是在主线程中被执行，取的是主线程的RunQueue队列，于是你在子线程post的Runnable就没法被执行了。
reference: 两者区别
