Android中消息机制中一些细节知识点

时隔很久，重温Android消息机制，注意到这么两个东西

MessageQueue中的IdleHandler

看MessageQueue的源码发现，里面有个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.         * 在当前线程变为空闲状态的时候执行，返回值代表是否保留该对象，如果返回false，那么该对象执行一次之后会被移除。         */        boolean queueIdle();    }

它体现在MessageQueue.next()方法中。

    Message next() {        // 省略部分代码        int pendingIdleHandlerCount = -1; // -1 only during first iteration        for (;;) {            if (nextPollTimeoutMillis != 0) {                Binder.flushPendingCommands();            }            nativePollOnce(ptr, nextPollTimeoutMillis);            synchronized (this) {                // 省略部分代码                // 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);            }// end of synchronized (this)            // 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("MessageQueue", "IdleHandler threw exception", t);                }                if (!keep) {// 由此可见，IdleHandler返回值的作用                    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;        }    }

注意，这个IdleHandler的执行是每调用一次next()方法才会执行一次。

那么这个类的用处就显而易见了，当我们需要在线程空闲时执行一些操作的话，就可以利用这个类来做。使用方式如下

Looper.myQueue().addIdleHandler(new MessageQueue.IdleHandler() {            @Override            public boolean queueIdle() {                // do something                return false;            }        });

MessageQueue中的同步阻塞器

其实，同步阻塞器的本质依旧是一个Message，只不过它的target为空。它存在于消息队列中。同步阻塞器在插入后会返回一个token值，移除则是通过token值来进行。插入和移除的过程就不看了，它正常消息的插入移除很相似，都需要在消息队列中寻找一个合适的位置进行插入。看看它在消息队列中生效的地方。依旧看next()方法

Message next() {        // 省略部分代码        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) {                    // msg.target == null 就代表该msg是同步阻塞器。正常通过Handler发送的消息msg.target都不可能为空的。                    // Stalled by a barrier.  Find the next asynchronous message in the queue.                    do {                    // 如果走到这里，则需要找一个异步的消息，Message的同步与异步的差别在这里就体现出来了，同步的消息会受阻塞器的影响，而异步消息不会。                        prevMsg = msg;                        msg = msg.next;                    } while (msg != null && !msg.isAsynchronous());                }                if (msg != null) {// 这里的msg不可能是同步阻塞器。                    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) {// 代表着得到的msg是异步消息                            prevMsg.next = msg.next;                        } else {                            mMessages = msg.next;                        }                        msg.next = null;                        if (false) Log.v("MessageQueue", "Returning message: " + msg);                        return msg;                    }                } else {                    // No more messages.                    nextPollTimeoutMillis = -1;                }                 // 省略部分代码            }// end of synchronized (this)            // 省略部分代码        }    }

这里我们要注意一点，同步阻塞器是无法阻塞在阻塞器生效前的同步消息。所以，当某个消息队列被阻塞器阻塞之后，要想执行操作，就需要你移除阻塞器或者发送异步消息。

MessageQueue中的IdleHandler

MessageQueue中的同步阻塞器

更多相关文章

随机推荐