Handler.post()源码分析

在分析post源码时候我们先看看Message里面是什么

public final class Message implements Parcelable {
        ****public int what;
        Runnable callback;
        **Message next;**
        Handler target;
        **public long when;**
        Bundle data;
    }

从此看的出Message是一个链表的节点，ok看看post

public final boolean post(@NonNull Runnable r) {
        return sendMessageDelayed(getPostMessage(r), 0);
    }
<pre><code>public final boolean postDelayed(@NonNull Runnable r, long delayMillis) {
    return sendMessageDelayed(getPostMessage(r), delayMillis);
}

public final boolean sendMessage(@NonNull Message msg) {
    return sendMessageDelayed(msg, 0);
}

public final boolean sendMessageDelayed(@NonNull Message msg, long delayMillis) {
    if (delayMillis &lt; 0) {
        delayMillis = 0;
    }
    return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
}

public boolean sendMessageAtTime(@NonNull 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);
}

private boolean enqueueMessage(@NonNull MessageQueue queue, @NonNull Message msg,
                               long uptimeMillis) {
    msg.target = this;
    msg.workSourceUid = ThreadLocalWorkSource.getUid();

    if (mAsynchronous) {
        msg.setAsynchronous(true);
    }
    return queue.enqueueMessage(msg, uptimeMillis);
}

由此可知，不管是post，还是postdelay实际上调用的都是queue的enqueue，uptimeMillis用的是系统时间 + delay的时间，msg是包装出来的Message，这个我就不读了，现在看看enqueueMessage

boolean enqueueMessage(Message msg, long when) {
if (msg.target == null) {
throw new IllegalArgumentException("Message must have a target.");
}</p>
<pre><code>    synchronized (this) {
        if (msg.isInUse()) {
            throw new IllegalStateException(msg + " This message is already in use.");
        }

        if (mQuitting) {
            IllegalStateException e = new IllegalStateException(
                    msg.target + " sending message to a Handler on a dead thread");
            Log.w(TAG, e.getMessage(), e);
            msg.recycle();
            return false;
        }

        msg.markInUse();
        msg.when = when;
        Message p = mMessages;
        boolean needWake;
        if (p == null || when == 0 || when &lt; 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 &amp;&amp; p.target == null &amp;&amp; msg.isAsynchronous();
            Message prev;
            for (; ; ) {
                prev = p;
                p = p.next;
                **if (p == null || when &lt; p.when) {
                    break;
                }**
                if (needWake &amp;&amp; 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;
}

看看这是什么呀

Message p = mMessages;
<strong>msg.next = p;
mMessages = msg;
典型的链表头插法，mMessage为头结点</strong>
if (p == null || when == 0 || when < p.when)
<strong>if (p == null || when < p.when) {
break;
}
寻找when时间小于Message.when的节点
大家懂了吧
这就是按照时间降序排序的Message的链表啊</strong>

盲猜Looper取Message时肯定往时间越小的那，拿尾节点实现，按照时间执行handleMessage啊

现在我们看看Looper.loop()是怎么拿东西的

public static void loop() {
Message msg = queue.next();
for (;;) {
....
Message msg = queue.next(); // might block
if (msg == null) {
// No message indicates that the message queue is quitting.
return;
}
.....
msg.target.dispatchMessage(msg);
.....
msg.recycleUnchecked();
}</p>
<pre><code>}

现在我们去看看queue.next() 看看是不是我说的那样

Message next() {
........
<strong>Message prevMsg = null;
Message msg = mMessages;</strong>
if (msg != null && msg.target == null) {
// Stalled by a barrier.  Find the next asynchronous message in the queue.
do {
prevMsg = msg;
msg = msg.next;
} <strong>while (msg != null && !msg.isAsynchronous());</strong>
}
if (msg != null) {
if (now < msg.when) {
// Next message is not ready.  Set a timeout to wake up when it is ready.
nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);
} else {
// Got a message.
mBlocked = false;
if (prevMsg != null) {
prevMsg.next = msg.next;
} else {
mMessages = msg.next;
}
msg.next = null;
if (DEBUG) Log.v(TAG, "Returning message: " + msg);
msg.markInUse();
<strong>return msg;</strong>
}
} else {
// No more messages.
nextPollTimeoutMillis = -1;
}</p>
<pre><code>    // Process the quit message now that all pending messages have been handled.
    if (mQuitting) {
        dispose();
        return null;
    }
   .......
}

看到了吧 ，从头开始遍历，一直到取尾巴节点