handler源码分析之MessageQueue

MessageQueue由Looper派发消息列表，不能够直接添加Message到MessageQueue，而是通过与Looper关联的Handler对象添加,可以使用Looper#myQueue()检索当前线程的MessageQueue.

总结

MessageQueue消息队列，通过Handler调用enqueueMessage方法把Message添加到队列中，根据when循环遍历队列，并把消息放入指定的位置，校验是否需要唤醒线程。MessageQueue有一个消息屏障的概念，它本质上一个Message，与其不同的是Target==null，并且args是token，消息屏障的作用是过滤同步消息，拦截异步消息。
Looper在轮询时调用的是消息队列next方法，把Message传递给Looper，next方法首先黑判断队列中是否有消息屏障，如果有只发送异步消息，如果没有，就依次进行发送，当消息队列中没有Message时，next方法阻塞线程，等待新的消息到来，在阻塞线程之前，此方法会阻塞线程前，会执行IdleHandler，所谓的阻塞其实就是不断的轮询新的消息。
当调用quit方法是，mQuitting会变成true，MessageQueue将要被关闭，可以根据传递的参数safe选择是否安全的关闭，所谓安全的关闭是指，以当前的时间为节点，大于当前时间的Message会被删除小于当前时间节点的消息会被保留到执行完毕。而不安全的退出消息队列就是把整个mMessage设置为null。然后在looper轮询时next方法返回为null，通知looper消息队列已经关闭，Looper可以关闭了。
Handler线程里实际上有两个无限循环体，Looper循环体和MessageQueue循环体，真正阻塞的地方是在MessageQueue的next()方法里

变量 Message mMessages

在MessageQueue中所有的Message都是以链表的形式组织在一起的，mMessages保存了链表的第一个元素，也可以说是链表本身。

private long mPtr;
该变量用于保存native代码中MessageQueue的指针。
mQuitAllowed
该变量用于标识消息队列是否可以被关闭，主线程的消息队列不可关闭。
private final ArrayList<IdleHandler> mIdleHandlers = new ArrayList<IdleHandler>();
当Handler线程处于空闲状态的时候（MessageQueue中没有其他Message时），可以利用它来处理一些事物，该变量就是用于保存这些在空闲时候要处理的事物。
private IdleHandler[] mPendingIdleHandlers
用于保存将要被执行的IdleHandler。
private boolean mQuitting
标识MessageQueue是否正在关闭。
private boolean mBlocked
标识MessageQueue是否阻塞。
private int mNextBarrierToken
在MessageQueue中有一个概念叫消息屏障，它用于拦截同步Message，阻止这些消息被执行，只有异步Message才会放行。消息屏障本身也是一个Message，只是它的target为null并且arg1用于区分不同的消息屏障，所以该变量就是用于不断累加生成不同的消息屏障。

构造

MessageQueue(boolean quitAllowed) {
        mQuitAllowed = quitAllowed;
        mPtr = nativeInit();
    }

接受一个参数quitAllowed，表示消息队列是否允许退出。MessageQueue目前我发现在Looper构造的时候传递的。
而构造在Looper#prepare方法中和prepareMainLooper贴上代码

public static void prepareMainLooper() {
        prepare(false);
        synchronized (Looper.class) {
            if (sMainLooper != null) {
                throw new IllegalStateException("The main Looper has already been prepared.");
            }
            sMainLooper = myLooper();
        }
    }

public static void prepare() {
        prepare(true);
    }

    private static void prepare(boolean quitAllowed) {
        if (sThreadLocal.get() != null) {
            throw new RuntimeException("Only one Looper may be created per thread");
        }
        sThreadLocal.set(new Looper(quitAllowed));
    }

我们默认使用的MainLooper，但是也可以在自己去调用。

isIdle()判断Looper是否空闲

/**
     * Returns true if the looper has no pending messages which are due to be processed.
     *
     * <p>This method is safe to call from any thread.
     *
     * @return True if the looper is idle.
     */
    public boolean isIdle() {
        synchronized (this) {
            final long now = SystemClock.uptimeMillis();
            return mMessages == null || now < mMessages.when;
        }
    }

IdleHandler addIdleHandler removeIdleHandler

IdleHandler是一个接口，用于在线程空闲时候处理一些业务。
queueIdle是接口内部的一个方法，返回Boolean值，当消息队列中的消息都处理完毕，就会调用这个方法，返回值为true时，IdleHandler会一直保持在消息队列中，，False则会执行完该方法后移除该IdleHandler。
需要注意的是，消息队列中还有其他延迟消息时，IdleHandler也会被调用，因为线程在此时是空闲的。

/**
     * Callback interface for discovering when a thread is going to block
     * waiting for more messages.
     */
    public static interface IdleHandler {
        /**
         * Called when the message queue has run out of messages and will now
         * wait for more.  Return true to keep your idle handler active, false
         * to have it removed.  This may be called if there are still messages
         * pending in the queue, but they are all scheduled to be dispatched
         * after the current time.
         */
        boolean queueIdle();
    }

添加一个新的IdleHandler到MessageQueue中。当IdleHandler接口的回调方法queueIdle返回false时，该IdleHandler在被执行完毕后，立即自动删除，当然也可以调用removeIdleHandler来删除指定的IdleHandler。此方法在任何线程都是线程安全的。

 /**
     * Add a new {@link IdleHandler} to this message queue.  This may be
     * removed automatically for you by returning false from
     * {@link IdleHandler#queueIdle IdleHandler.queueIdle()} when it is
     * invoked, or explicitly removing it with {@link #removeIdleHandler}.
     *
     * <p>This method is safe to call from any thread.
     *
     * @param handler The IdleHandler to be added.
     */
    public void addIdleHandler(@NonNull IdleHandler handler) {
        if (handler == null) {
            throw new NullPointerException("Can't add a null IdleHandler");
        }
        synchronized (this) {
            mIdleHandlers.add(handler);
        }
    }

//从消息队列中移除一个之前添加的IdleHandler。如果该IdleHandler不存在，则不会发生任何事情。

/**
     * Remove an {@link IdleHandler} from the queue that was previously added
     * with {@link #addIdleHandler}.  If the given object is not currently
     * in the idle list, nothing is done.
     *
     * <p>This method is safe to call from any thread.
     *
     * @param handler The IdleHandler to be removed.
     */
    public void removeIdleHandler(@NonNull IdleHandler handler) {
        synchronized (this) {
            mIdleHandlers.remove(handler);
        }
    }

isPolling

/**
     * Returns whether this looper's thread is currently polling for more work to do.
     * This is a good signal that the loop is still alive rather than being stuck
     * handling a callback.  Note that this method is intrinsically racy, since the
     * state of the loop can change before you get the result back.
     *
     * <p>This method is safe to call from any thread.
     *
     * @return True if the looper is currently polling for events.
     * @hide
     */
    public boolean isPolling() {
        synchronized (this) {
            return isPollingLocked();
        }
    }

    private boolean isPollingLocked() {
        // If the loop is quitting then it must not be idling.
        // We can assume mPtr != 0 when mQuitting is false.
        return !mQuitting && nativeIsPolling(mPtr);
    }

返回当前线程的Looper是否正在轮询，此方法是安全的。

addOnFileDescriptorEventListener

 /**
     * Adds a file descriptor listener to receive notification when file descriptor
     * related events occur.
     * <p>
     * If the file descriptor has already been registered, the specified events
     * and listener will replace any that were previously associated with it.
     * It is not possible to set more than one listener per file descriptor.
     * </p><p>
     * It is important to always unregister the listener when the file descriptor
     * is no longer of use.
     * </p>
     *
     * @param fd The file descriptor for which a listener will be registered.
     * @param events The set of events to receive: a combination of the
     * {@link OnFileDescriptorEventListener#EVENT_INPUT},
     * {@link OnFileDescriptorEventListener#EVENT_OUTPUT}, and
     * {@link OnFileDescriptorEventListener#EVENT_ERROR} event masks.  If the requested
     * set of events is zero, then the listener is unregistered.
     * @param listener The listener to invoke when file descriptor events occur.
     *
     * @see OnFileDescriptorEventListener
     * @see #removeOnFileDescriptorEventListener
     */
    public void addOnFileDescriptorEventListener(@NonNull FileDescriptor fd,
            @OnFileDescriptorEventListener.Events int events,
            @NonNull OnFileDescriptorEventListener listener) {
        if (fd == null) {
            throw new IllegalArgumentException("fd must not be null");
        }
        if (listener == null) {
            throw new IllegalArgumentException("listener must not be null");
        }

        synchronized (this) {
            updateOnFileDescriptorEventListenerLocked(fd, events, listener);
        }
    }

    /**
     * Removes a file descriptor listener.
     * <p>
     * This method does nothing if no listener has been registered for the
     * specified file descriptor.
     * </p>
     *
     * @param fd The file descriptor whose listener will be unregistered.
     *
     * @see OnFileDescriptorEventListener
     * @see #addOnFileDescriptorEventListener
     */
    public void removeOnFileDescriptorEventListener(@NonNull FileDescriptor fd) {
        if (fd == null) {
            throw new IllegalArgumentException("fd must not be null");
        }

        synchronized (this) {
            updateOnFileDescriptorEventListenerLocked(fd, 0, null);
        }
    }

    private void updateOnFileDescriptorEventListenerLocked(FileDescriptor fd, int events,
            OnFileDescriptorEventListener listener) {
        final int fdNum = fd.getInt$();

        int index = -1;
        FileDescriptorRecord record = null;
        if (mFileDescriptorRecords != null) {
            index = mFileDescriptorRecords.indexOfKey(fdNum);
            if (index >= 0) {
                record = mFileDescriptorRecords.valueAt(index);
                if (record != null && record.mEvents == events) {
                    return;
                }
            }
        }

        if (events != 0) {
            events |= OnFileDescriptorEventListener.EVENT_ERROR;
            if (record == null) {
                if (mFileDescriptorRecords == null) {
                    mFileDescriptorRecords = new SparseArray<FileDescriptorRecord>();
                }
                record = new FileDescriptorRecord(fd, events, listener);
                mFileDescriptorRecords.put(fdNum, record);
            } else {
                record.mListener = listener;
                record.mEvents = events;
                record.mSeq += 1;
            }
            nativeSetFileDescriptorEvents(mPtr, fdNum, events);
        } else if (record != null) {
            record.mEvents = 0;
            mFileDescriptorRecords.removeAt(index);
        }
    }

翻译:添加文件描述监听，当文件描述相关事件发生变化会接受到通知。
如果文件描述事件已经被注册，那么指定的Event和Listener会替换以前事件和监听。每个文件描述符不能指定多个监听。不需要文件描述监听，就把他注销掉removeOnFileDescriptorEventListener。

FileDescriptor 是“文件描述符”。
FileDescriptor 可以被用来表示开放文件、开放套接字等。
以FileDescriptor表示文件来说：当FileDescriptor表示某文件时，我们可以通俗的将FileDescriptor看成是该文件。但是，我们不能直接通过FileDescriptor对该文件进行操作；若需要通过FileDescriptor对该文件进行操作，则需要新创建FileDescriptor对应的FileOutputStream，再对文件进行操作
FileDescriptor相关文章
http://www.jianshu.com/p/430340c4a37a
http://www.jianshu.com/p/a2dc2907ec28
http://www.jianshu.com/p/837320d6faea
http://blog.csdn.net/yuanzhangmei1/article/details/9131971

目前还不知道addOnFileDescriptorEventListener是在哪里调用的，既然FileDescriptor也是做Io操作，肯定也是对文件操作

来看看 updateOnFileDescriptorEventListenerLocked方法，从移除监听可以看出来，event 是int值，如果传入0，代表移除监听。

这个方法让我蒙圈了，不管了，继续往下

/**
    /**
     * Returns the int descriptor. It's highly unlikely you should be calling this. Please discuss
     * your needs with a libcore maintainer before using this method.
     * @hide internal use only
     */
    // Android-added.
    public final int getInt$() {
        return descriptor;
    }

下面这段代码

int index = -1;
        FileDescriptorRecord record = null;
        if (mFileDescriptorRecords != null) {
            index = mFileDescriptorRecords.indexOfKey(fdNum);
            if (index >= 0) {
                record = mFileDescriptorRecords.valueAt(index);
                if (record != null && record.mEvents == events) {
                    return;
                }
            }
        }

FileDescriptorRecord是存放监听，事件，文件描述符的实体类，根据getInt$的返回值作为键，去集合中找这个值，SparseArray看成是HashMap，1.如果真有且集合不为null，并且事件相同那就直接返回了。

if (events != 0) {
            events |= OnFileDescriptorEventListener.EVENT_ERROR;
            if (record == null) {
                if (mFileDescriptorRecords == null) {
                    mFileDescriptorRecords = new SparseArray<FileDescriptorRecord>();
                }
                record = new FileDescriptorRecord(fd, events, listener);
                mFileDescriptorRecords.put(fdNum, record);
            } else {
                record.mListener = listener;
                record.mEvents = events;
                record.mSeq += 1;
            }
            nativeSetFileDescriptorEvents(mPtr, fdNum, events);
        } else if (record != null) {
            record.mEvents = 0;
            mFileDescriptorRecords.removeAt(index);
        }

这部分就很好理解，就是把FileDescriptorRecord对象以fdNum为键存进集合中。

dispatchEvents

// Called from native code.
    private int dispatchEvents(int fd, int events) {
        // Get the file descriptor record and any state that might change.
        final FileDescriptorRecord record;
        final int oldWatchedEvents;
        final OnFileDescriptorEventListener listener;
        final int seq;
        synchronized (this) {
            record = mFileDescriptorRecords.get(fd);
            if (record == null) {
                return 0; // spurious, no listener registered
            }

            oldWatchedEvents = record.mEvents;
            events &= oldWatchedEvents; // filter events based on current watched set
            if (events == 0) {
                return oldWatchedEvents; // spurious, watched events changed
            }

            listener = record.mListener;
            seq = record.mSeq;
        }

        // Invoke the listener outside of the lock.
        int newWatchedEvents = listener.onFileDescriptorEvents(
                record.mDescriptor, events);
        if (newWatchedEvents != 0) {
            newWatchedEvents |= OnFileDescriptorEventListener.EVENT_ERROR;
        }

        // Update the file descriptor record if the listener changed the set of
        // events to watch and the listener itself hasn't been updated since.
        if (newWatchedEvents != oldWatchedEvents) {
            synchronized (this) {
                int index = mFileDescriptorRecords.indexOfKey(fd);
                if (index >= 0 && mFileDescriptorRecords.valueAt(index) == record
                        && record.mSeq == seq) {
                    record.mEvents = newWatchedEvents;
                    if (newWatchedEvents == 0) {
                        mFileDescriptorRecords.removeAt(index);
                    }
                }
            }
        }

        // Return the new set of events to watch for native code to take care of.
        return newWatchedEvents;
    }

这个方法由native调用
传递2个参数，int fd int events
第一行注释代码说明：获取文件描述符记录和可能更改的任何状态。
根据int 值，从集合取出对应的实体对象，如果对象=null，则返回0，代表没有监听，把对象的数据获取出来进行赋值运算，根据当前的事件过滤，（）然后执行onFileDescriptorEvents方法，获取新的events事件。接下来就判断需不需要更新这个事件。

消息屏障

消息屏障也是一个Message，与其他消息不同的是消息屏障的Target=null，when=当前毫秒值，arg1是token，用于区分不同消息屏障,消息屏障的作用是拦截同步消息队列中的同步消息，放行异步消息。（在next方法中的do while中体现，只有消息屏障Target可以为空null，其他的Target为null直接抛异常了）

添加消息屏障到队列

public int postSyncBarrier() {
        return postSyncBarrier(SystemClock.uptimeMillis());
    }

    private int postSyncBarrier(long when) {
        // Enqueue a new sync barrier token.
        // We don't need to wake the queue because the purpose of a barrier is to stall it.
        synchronized (this) {
            final int token = mNextBarrierToken++;
            final Message msg = Message.obtain();
            msg.markInUse();
            msg.when = when;
            msg.arg1 = token;

            Message prev = null;
            Message p = mMessages;
            if (when != 0) {
                while (p != null && p.when <= when) {
                    prev = p;
                    p = p.next;
                }
            }
            if (prev != null) { // invariant: p == prev.next
                msg.next = p;
                prev.next = msg;
            } else {
                msg.next = p;
                mMessages = msg;
            }
            return token;
        }
    }

添加消息屏障到消息队列，when是当前时间执行点。arg1的值是token，消息屏障的唯一标识，值递增。final Message msg = Message.obtain();这个msg就是消息屏障，它的Target是null。
断言when>0,p!=null,循环遍历消息队列，利用when进行比较，p.when只要小于when的都插入到队列前面.

m3 -- m2 --m1--m0
如果m3的when小于msg的when
m3 -- Barrier--m2--m1--m0
如果m3的when大于msg的when
Barrier--m3--m2--m1--m0

最后返回一个新的Token。

移除消息屏障

/**
     * Removes a synchronization barrier.
     *
     * @param token The synchronization barrier token that was returned by
     * {@link #postSyncBarrier}.
     *
     * @throws IllegalStateException if the barrier was not found.
     *
     * @hide
     */
    public void removeSyncBarrier(int token) {
        // Remove a sync barrier token from the queue.
        // If the queue is no longer stalled by a barrier then wake it.
        synchronized (this) {
            Message prev = null;
            Message p = mMessages;
            while (p != null && (p.target != null || p.arg1 != token)) {
                prev = p;
                p = p.next;
            }
            if (p == null) {
                throw new IllegalStateException("The specified message queue synchronization "
                        + " barrier token has not been posted or has already been removed.");
            }
            final boolean needWake;
            if (prev != null) {
                prev.next = p.next;
                needWake = false;
            } else {
                mMessages = p.next;
                needWake = mMessages == null || mMessages.target != null;
            }
            p.recycleUnchecked();

            // If the loop is quitting then it is already awake.
            // We can assume mPtr != 0 when mQuitting is false.
            if (needWake && !mQuitting) {
                nativeWake(mPtr);
            }
        }
    }

删除消息屏障比较简单，遍历消息队列匹配token，在释放资源之前排列好队列。

重要方法 enqueueMessage

boolean enqueueMessage(Message msg, long when) {
//tartget不能为null，需要知道是那个Handler发送到消息队列，也是根据这个Target吧结果返回给指定的Handler
        if (msg.target == null) {
            throw new IllegalArgumentException("Message must have a target.");
        }
//不能添加正在使用的Message到消息队列
        if (msg.isInUse()) {
            throw new IllegalStateException(msg + " This message is already in use.");
        }
        synchronized (this) {
//如果消息队列只能退出，不会接受Message，返回False，告诉Handler添加消息失败，并释放资源，把Message添加到回收池中。
            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;
            }
  //标记Message正在使用，
            msg.markInUse();
            msg.when = when;
            Message p = mMessages;
            boolean needWake;
//如果消息队列没有Message，或者要添加的消息延时时间是0，或者需要加入到队列的Message时间节点小于链表第一个Message，都会把这个消息直接放入消息队列的头。
            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.
//把msg插入到适合的位置，根据when，msg与p比较，把p插入msg的后面，msg插入prew的前面。prew最初是mMessage。
                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插入到消息队列中，首先判断Target，其次是否在使用中，如果消息队列正在退出，则添加消息失败，释放资源。
在真正加添消息钱，把Message标记成正在使用。
消息添加到队列

p==null 表示队列中没有消息，放入到列表头。
when=0 表示此消息需要立即发送，直接加入到列表的头。
再此消息列表中，时间节点小于其他Message。
满足上面其中一种情况，Message直接加入MessageQueue中。

否则：
进入死循环，遍历Message，根据when找到合适的位置进行插入。（next获取下一个Message，如果下一个Message的when大于当钱msg的when，将msg.next赋值给Message，msg.next赋值给p.next,这样就行形成一个链表）
最后判断是否唤醒线程。native方法调用。返回true表示Message加入MessageQueue成功。

移除消息系列

 void removeMessages(Handler h, int what, Object object) {
        if (h == null) {
            return;
        }

        synchronized (this) {
            Message p = mMessages;

            // Remove all messages at front.
            while (p != null && p.target == h && p.what == what
                   && (object == null || p.obj == object)) {
                Message n = p.next;
                mMessages = n;
                p.recycleUnchecked();
                p = n;
            }

            // Remove all messages after front.
            while (p != null) {
                Message n = p.next;
                if (n != null) {
                    if (n.target == h && n.what == what
                        && (object == null || n.obj == object)) {
                        Message nn = n.next;
                        n.recycleUnchecked();
                        p.next = nn;
                        continue;
                    }
                }
                p = n;
            }
        }
    }

    void removeMessages(Handler h, Runnable r, Object object) {
        if (h == null || r == null) {
            return;
        }

        synchronized (this) {
            Message p = mMessages;

            // Remove all messages at front.
            while (p != null && p.target == h && p.callback == r
                   && (object == null || p.obj == object)) {
                Message n = p.next;
                mMessages = n;
                p.recycleUnchecked();
                p = n;
            }

            // Remove all messages after front.
            while (p != null) {
                Message n = p.next;
                if (n != null) {
                    if (n.target == h && n.callback == r
                        && (object == null || n.obj == object)) {
                        Message nn = n.next;
                        n.recycleUnchecked();
                        p.next = nn;
                        continue;
                    }
                }
                p = n;
            }
        }
    }

    void removeCallbacksAndMessages(Handler h, Object object) {
        if (h == null) {
            return;
        }

        synchronized (this) {
            Message p = mMessages;

            // Remove all messages at front.
            while (p != null && p.target == h
                    && (object == null || p.obj == object)) {
                Message n = p.next;
                mMessages = n;
                p.recycleUnchecked();
                p = n;
            }

            // Remove all messages after front.
            while (p != null) {
                Message n = p.next;
                if (n != null) {
                    if (n.target == h && (object == null || n.obj == object)) {
                        Message nn = n.next;
                        n.recycleUnchecked();
                        p.next = nn;
                        continue;
                    }
                }
                p = n;
            }
        }
    }
    //移除所有未执行的Message。
    private void removeAllMessagesLocked() {
        Message p = mMessages;
        while (p != null) {
            Message n = p.next;
            p.recycleUnchecked();
            p = n;
        }
        mMessages = null;
    }

/**
     * 移除所有执行时间点在当前时间点之后的Message，而在当前时间点之前的Message会保留在消息队列中，
     * 直到它们都被处理完为止。
     */
    private void removeAllFutureMessagesLocked() {
        final long now = SystemClock.uptimeMillis();
        Message p = mMessages;
        if (p != null) {
            if (p.when > now) {
                removeAllMessagesLocked();
            } else {
                Message n;
                for (;;) {
                    n = p.next;
                    if (n == null) {
                        return;
                    }
                    if (n.when > now) {
                        break;
                    }
                    p = n;
                }
                p.next = null;
                do {
                    p = n;
                    n = p.next;
                    p.recycleUnchecked();
                } while (n != null);
            }
        }
    }

removeMessages 上半部分

while (p != null && p.target == h && p.what == what
                   && (object == null || p.obj == object)) {
                Message n = p.next;
                mMessages = n;
                p.recycleUnchecked();
                p = n;
            }

如果消息队列的头就有符合条件的Message，就从头开始删除符合条件的Message，并不断地更新mMessage的指向。

removeMessages 后半部分

// Remove all messages after front.
            while (p != null) {
                Message n = p.next;
                if (n != null) {
                    if (n.target == h && n.what == what
                        && (object == null || n.obj == object)) {
                        Message nn = n.next;
                        n.recycleUnchecked();
                        p.next = nn;
                        continue;
                    }
                }
                p = n;
            }

到了这里前半部分没有满足，所以不会发生，不在需要关系指向问题，直接删除符合条件的Message。

从消息队列中删除Message的操作也是遍历消息队列然后删除所有符合条件的Message，但是这里有个小细节需要注意，从代码中可以看出删除Message分为两次操作，第一次是先判断符合删除条件的Message是不是从消息队列的头部就开始有了，这是时候会涉及到修改mMessages指向的问题，而mMessages代表的就是整个消息队列；在排除了第一种情况之后，剩下的就是继续遍历队列删除剩余的符合删除条件的Message。其他重载方法也是同样的操作，唯一的区别就是删除条件不同而已。

关闭消息队列

void quit(boolean safe) {
        // 判断当前的消息队列是否允许被关闭，主线程就不允许。
        if (!mQuitAllowed) {
            throw new IllegalStateException("Main thread not allowed to quit.");
        }

        synchronized (this) {
            if (mQuitting) {
                return;
            }
            mQuitting = true;

            if (safe) {
                removeAllFutureMessagesLocked();
            } else {
                removeAllMessagesLocked();
            }

            // We can assume mPtr != 0 because mQuitting was previously false.
            nativeWake(mPtr);
        }
    }

quit(false)

这是一种强制关闭消息队列的方式，这种做法是不安全的方式，因为它会直接删除队列中所有未执行的Message，这一点可以从removeAllMessagesLocked()方法看出。

quit(true)

安全关闭消息队列的方式，从removeAllFutureMessagesLocked()可以看出，这种方式会删除消息队列中所有还没有到达执行时间点的Message，而剩下的已经达到执行时间点的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;
        }

        //记录空闲时处理IdleHandler的数量
        int pendingIdleHandlerCount = -1; // -1 only during first iteration
        //阻塞线程时间 具体看下面
        int nextPollTimeoutMillis = 0;
        for (;;) {
            if (nextPollTimeoutMillis != 0) {
                //释放可是释放的资源
                Binder.flushPendingCommands();
            }
            //调用native方法来阻塞线程
            nativePollOnce(ptr, nextPollTimeoutMillis);

            synchronized (this) {
                // Try to retrieve the next message.  Return if found.
                // 需要操作的msg和需要进行比较的时间
                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());
                }
               //  判断还有没有可用的Message
                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 {
                        //  执行的时间到了
                        //重新排列Message
                        // 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.
                    //  没有Message了，可以睡觉了。
                    nextPollTimeoutMillis = -1;
                }

                // Process the quit message now that all pending messages have been handled.
              // 关闭消息队列，返回null，通知Looper停止循环
                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.
                 // 第一次循环的空闲时候调用，所谓的空闲，指的是消息队列中没有Message了。
                if (pendingIdleHandlerCount < 0
                        && (mMessages == null || now < mMessages.when)) {
                    pendingIdleHandlerCount = mIdleHandlers.size();
                }
               // 这里厉害了如果判断成立则说明没有IdleHandler和Message了，直接下次循环阻塞线程。
                if (pendingIdleHandlerCount <= 0) {
                    // No idle handlers to run.  Loop and wait some more.
                    mBlocked = true;
                    continue;
                }

                if (mPendingIdleHandlers == null) {
                // 最小处理4个IdleHandler 具体看pendingIdleHandlerCount，如果只有2个呢？其他两个为Null？还是在其他什么地方调用，需要添加4个IdleHandler。主要还是看addIdleHandler方法在什么地方调用。
                    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.
            //开始执行所有的IdleHandler，在根据返回的keep决定是否删除。
            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.
            //idle handler都执行完了，当然要初始化了
            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.
          //在处理idle handler的时候耗费了一些时间，也许又有其他的Message到达了呢，重置变量，重新检查消息队列。
            nextPollTimeoutMillis = 0;
        }
    }

分开来写。还是写在代码上把。

final long ptr = mPtr;
        if (ptr == 0) {
            return null;
        }

mPtr是从native方法中得到的NativeMessageQueue地址
如果mPtr等于0说明队列不存在或被清除掉了

int pendingIdleHandlerCount = -1; // -1 only during first iteration
int nextPollTimeoutMillis = 0;

pendingIdleHandlerCount
在空闲时需要处理IdleHandler的数量，只有第一次初始化的时候才能为-1。
nextPollTimeoutMillis
通知native层阻塞线程
nextPollTimeoutMillis = -1 一直阻塞直到再次唤醒他
nextPollTimeoutMillis = 0 不阻塞线程
nextPollTimeoutMillis >0 阻塞线程多长时间
既然有阻塞线程，肯定也有唤醒线程，在enqueueMessage调用nativeWake(mPtr);唤醒线程。

接下来是一个死循环:
for(;;)

if (nextPollTimeoutMillis != 0) {
                Binder.flushPendingCommands();
}

如果!=0,说明要阻塞线程了。为了长时间阻塞线程释放掉部分对象。

nativePollOnce(ptr, nextPollTimeoutMillis);
这个方法可厉害了，就是这个方法来阻塞线程的，根据指定的ptr来阻塞，nextPollTimeoutMillis在上面呢。

final long now = SystemClock.uptimeMillis();
                Message prevMsg = null;
                Message msg = mMessages;

now以这个时间为基准开始比较，msg就是要发送给Looper的消息，主要看是如何对这两个Message进行操作的

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());
                }

目前，msg是队列的头，也是当前的队列，Target为null，只有一种情况，那就是消息屏障。if判断队列的头是不是消息屏障。

do while
不断地进行轮询，同步Message直接过滤,知道获取到第一个异步消息轮询结束。msg就是那个异步的Message，prevMes.next = msg;这里可以看的出来优先处理异步消息。过滤掉的消息不是指删除掉了，只是找到异步消息发送Looper，在下次循环的时候Message msg = mMessages;只有发送的异步消息从队列移除了。

//重新排列Message
                        // 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();
                      //  把消息返回

如果prewMsg

== null
执行的是同步消息，把mMessage这个消息队列重新赋值，next成了头。
!= null
代表执行的异步消息，也是重新排列队列。相当把异步消息移除。