post方法在View类和Handler类中都有，我们经常使用。
比如listview滑动到某个指定位置：
listview.post(new Runnable() {
@Override
public void run() {
listview.smoothScrollToPosition(listview.getCount() - 1);
}
});
软键盘弹出：
new Handler().postDelayed(() -> {
scrollView.scrollBy(0, keyboardHeight);
}, 200);
scrollview自动滑动到底部：
scrollView.post(new Runnable() {
@Override
public void run() {
scrollView.fullScroll(ScrollView.FOCUS_DOWN);
}
});
甚至，在post方法中获取控件宽高：
linleatLayout.post(new Runnable() {
@Override
public void run() {
int height = linearLayout.getHeight();
}
});
那么，View类中的post方法和Handler类中的post方法一样吗？post具体做了什么？是创建了一个子线程？我们一一弄清楚。我们先来看Handler类中的post方法。
关于handler类的发送消息方法，我们见过很多， 主要就是两种：post和sendMessage。
-
post系列的方法有：
post(Runnable r)，postAtTime(Runnable r, long uptimeMillis)，postDelayed(Runnable r, long delayMillis)
-
sendmessage系列的方法有：
sendMessage(Message msg)，sendMessageDelayed(Message msg, long delayMillis)，sendMessageAtTime(Message msg, long uptimeMillis)；
sendEmptyMessage(int what)，sendEmptyMessageDelayed(int what, long delayMillis)，sendEmptyMessageAtTime(int what, long uptimeMillis)
这两者有什么区别呢？可以看到，post传进去的参数是Runnable，sendMessage传进去的参数是Message。其实，Runnable最后都转为了Message。来看看源码。
post(Runnable r)：
public final boolean post(Runnable r) {
//通过getPostMessage得到一个Message对象，然后将我们创建的Runable对象作为callback属性，赋值给了此message.
return sendMessageDelayed(getPostMessage(r), 0);
}sendMessageDelayed()需要传入Message类型的参数，所以通过getPostMessage()方法来得到Message。再来看看getPostMessage。
getPostMessage(r):
private static Message getPostMessage(Runnable r) {
Message m = Message.obtain();
m.callback = r;
return m;
}
这里我们能看到，post传入的Runnable参数最终作为message的callback处理了。
再往下看sendMessageDelayed(Message msg,long delayMillis):
public final boolean sendMessageDelayed(Message msg, long delayMillis) {
if (delayMillis < 0) {
delayMillis = 0;
}
return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
}
sendMessageAtTime(Message msg, long uptimeMillis):
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方法里，首先获取到消息队列queue，然后调用enqueueMessage()方法把消息msg压入当前队列中。
所以说，post和sendMessage系列方法做的事情只是：把当前msg（post方法会先构造一个msg）压入消息队列。
接下来看看enqueueMessage是怎么工作的：
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
msg.target = this;
if (mAsynchronous) {
msg.setAsynchronous(true);
}
return queue.enqueueMessage(msg, uptimeMillis);
}
重点是queue.enqueueMessage(msg, uptimeMillis)，它是MessageQueue类里面的方法，把msg压入消息队列的具体操作在这个方法中进行，具体如下：
boolean enqueueMessage(Message msg, long when) {
//target是处理msg的handler
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("MessageQueue", 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;
}
搞清楚了post(Runnable r)，再来看看postAtTime(Runnable r, long uptimeMillis)：
public final boolean postAtTime(Runnable r, long uptimeMillis) {
return sendMessageAtTime(getPostMessage(r), uptimeMillis);
}
实质也是调用sendMessageAtTime方法。
postDelayed(Runnable r, long delayMillis)：
public final boolean postDelayed(Runnable r, long delayMillis) {
return sendMessageDelayed(getPostMessage(r), delayMillis);
}
postDelayed调用的是sendMessageDelayed，而sendMessageDelayed在上面的源码中能看到，调用的还是sendMessageAtTime。
post方法搞清楚了，再来看看sendMessage系列。
sendMessage(Message msg)：
public final boolean sendMessage(Message msg) {
return sendMessageDelayed(msg, 0);
}
sendEmptyMessage(int what)：
public final boolean sendEmptyMessage(int what) {
return sendEmptyMessageDelayed(what, 0);
}
sendEmptyMessageDelayed(int what, long delayMillis)：
public final boolean sendEmptyMessageDelayed(int what, long delayMillis) {
Message msg = Message.obtain();
msg.what = what;
return sendMessageDelayed(msg, delayMillis);
}
sendEmptyMessageAtTime(int what, long uptimeMillis)：
public final boolean sendEmptyMessageAtTime(int what, long uptimeMillis) {
Message msg = Message.obtain();
msg.what = what;
return sendMessageAtTime(msg, uptimeMillis);
}
看到这里全明白了吧？总结一下：
-
Handler类中发送消息有两种：Runnable 和 Message，对应方法为post(Runnable r) 和 sendMessage(Message msg, long delayMillis),不管是那种方法最后都会调用sendMessageAtTime(Message msg, long uptimeMillis)方法。
-
sendMessageAtTime方法的目的是把msg压入消息队列message queue中。
-
post方法 参数类型为Runnable，Message先构造出一个Message对象，Runnable作为Message的callback。
sendMessage则直接传入一个Message对象。
差点忘了，View类中的post方法还没说呢。
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;
}
参数也是Runnable类型的对象，attachInfo不为空时，返回attachInfo.mHandler.post(action)，它就是上面说过的handler类中的post方法：
public final boolean post(Runnable r){
return sendMessageDelayed(getPostMessage(r), 0);
}
attachInfo为空时，执行这一句 ViewRootImpl.getRunQueue().post(action);这个post方法实现如下：
void post(Runnable action) {
postDelayed(action, 0);
}
postDelayed(action,0)实现如下：
private final ArrayList<HandlerAction> mActions = new ArrayList<HandlerAction>();
void postDelayed(Runnable action, long delayMillis) {
HandlerAction handlerAction = new HandlerAction();
handlerAction.action = action;
handlerAction.delay = delayMillis;
synchronized (mActions) {
mActions.add(handlerAction);
}
}
private static class HandlerAction {
Runnable action;
long delay;
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
HandlerAction that = (HandlerAction) o;
return !(action != null ? !action.equals(that.action) : that.action != null);
}
@Override
public int hashCode() {
int result = action != null ? action.hashCode() : 0;
result = 31 * result + (int) (delay ^ (delay >>> 32));
return result;
}
}
}
扫一扫
9387
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
