对Handler中postDelayed(Runnable r, long delayMillis)的简单分析

平时在使用postDelayed这个方法的时候，总是好奇Runnable方法为什么可以根据指定的时间去延时执行，今天趁着空闲，看了一下内部源码，现在来简单分析下，如有不正确之处，欢迎留言指教。

我们可以追踪源码一步一步来看它里面到底是怎么实现的。

先来想象一下大概的问题。

我们的工作是放在线程Runnable中执行的，那么首先我们要知道Runnable被放到哪个地方去了，Runnable是如何根据我们设定的时间去按时执行的。废话讲的太多，下面开始来具体分析。

一，在我们实例化调用PostDelayed方法时，会传一个Runnable跟一个延迟时间，其实这个时候程序会把我们的Runnable对象赋给一个Message中的callback成员，该成员其实也是一个Runnable类型的。下面具体源码。

public final boolean postDelayed(Runnable r, long delayMillis)
    {
        return sendMessageDelayed(getPostMessage(r), delayMillis);
    }

    private static Message getPostMessage(Runnable r) {
        Message m = Message.obtain();
        m.callback = r;
        return m;
    }

让我们来继续追踪下去，会发现碰到一个enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis)方法，它里面调用的是MessageQueue里面的boolean enqueueMessage(Message msg, long when)方法。

private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
        msg.target = this;
        if (mAsynchronous) {
            msg.setAsynchronous(true);
        }
        return queue.enqueueMessage(msg, uptimeMillis);
    }

点到MessageQueue中的入队方法（enqueueMessage）。

boolean enqueueMessage(Message msg, long when) {
        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(TAG, 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;
    }

我们发现在该入队方法中，会把前面的Message对象赋给MessageQueue中的mMessages。那么为什么要赋给该属性呢？这里简单说下消息队列。在Android UI线程中存在一个Looper对象，它里面有一个loop方法，里面有一个无限的for循环，该无限循环里面有这么一个语句 Message msg = queue.next(); // might block，这是什么意思呢？其实是表示该无限循环里面在无休止的获取MessageQueue中的Message，我们可以来看下next()方法。

Message next() {
        // Return here if the message loop has already quit and been disposed.
        // This can happen if the application tries to restart a looper after quit
        // which is not supported.
        final long ptr = mPtr;
        if (ptr == 0) {
            return null;
        }

        int pendingIdleHandlerCount = -1; // -1 only during first iteration
        int nextPollTimeoutMillis = 0;
        for (;;) {
            if (nextPollTimeoutMillis != 0) {
                Binder.flushPendingCommands();
            }

            nativePollOnce(ptr, nextPollTimeoutMillis);

            synchronized (this) {
                // Try to retrieve the next message.  Return if found.
                final long now = SystemClock.uptimeMillis();
                Message prevMsg = null;
                Message msg = mMessages;
                if (msg != null && msg.target == null) {
                    // Stalled by a barrier.  Find the next asynchronous message in the queue.
                    do {
                        prevMsg = msg;
                        msg = msg.next;
                    } while (msg != null && !msg.isAsynchronous());
                }
                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();
                        return msg;
                    }
                } else {
                    // No more messages.
                    nextPollTimeoutMillis = -1;
                }

                // Process the quit message now that all pending messages have been handled.
                if (mQuitting) {
                    dispose();
                    return null;
                }

                // If first time idle, then get the number of idlers to run.
                // Idle handles only run if the queue is empty or if the first message
                // in the queue (possibly a barrier) is due to be handled in the future.
                if (pendingIdleHandlerCount < 0
                        && (mMessages == null || now < mMessages.when)) {
                    pendingIdleHandlerCount = mIdleHandlers.size();
                }
                if (pendingIdleHandlerCount <= 0) {
                    // No idle handlers to run.  Loop and wait some more.
                    mBlocked = true;
                    continue;
                }

                if (mPendingIdleHandlers == null) {
                    mPendingIdleHandlers = new IdleHandler[Math.max(pendingIdleHandlerCount, 4)];
                }
                mPendingIdleHandlers = mIdleHandlers.toArray(mPendingIdleHandlers);
            }

            // Run the idle handlers.
            // We only ever reach this code block during the first iteration.
            for (int i = 0; i < pendingIdleHandlerCount; i++) {
                final IdleHandler idler = mPendingIdleHandlers[i];
                mPendingIdleHandlers[i] = null; // release the reference to the handler

                boolean keep = false;
                try {
                    keep = idler.queueIdle();
                } catch (Throwable t) {
                    Log.wtf(TAG, "IdleHandler threw exception", t);
                }

                if (!keep) {
                    synchronized (this) {
                        mIdleHandlers.remove(idler);
                    }
                }
            }

            // Reset the idle handler count to 0 so we do not run them again.
            pendingIdleHandlerCount = 0;

            // While calling an idle handler, a new message could have been delivered
            // so go back and look again for a pending message without waiting.
            nextPollTimeoutMillis = 0;
        }
    }

它里面有这么判断if (now < msg.when)，其中now是当前的时间，msg.when是我们刚开始设置的时间（注意不是我们设置的5000，6000之类的，而是加上了我们程序启动时的时间）。当now等于了我们所设置的时间后，执行下面的语句（关键代码）

// 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();
       return msg;

将属于我们的哪个Message传给loop方法。这个时候msg不为null,程序继续执行，会碰到msg.target.dispatchMessage(msg);这行语句，它的作用是将Message又传回给Handler，就完成了我们之间设定的时间间隔。

有不对的地方，欢迎讨论哦~~~