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标记成正在使用。
消息添加到队列

  1. p==null 表示队列中没有消息,放入到列表头。
  2. when=0 表示此消息需要立即发送,直接加入到列表的头。
  3. 再此消息列表中,时间节点小于其他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
    代表执行的异步消息,也是重新排列队列。相当把异步消息移除。