Handler，MessageQueue，Looper，你所不知道的Asynchronous

结合源码分析Handler还是可以异步的。首先介绍下 Android 消息处理机制相关的几个类：

1，Message：消息实体；

2，MessageQueue：消息队列；

3，Looper：消息循环体；

4，Handler：消息处理；

消息处理的机制，开始于 Looper.prepare()，Looper.loop()，那看看 Looper.loop() 的源码：

    public static void loop() {        //省略代码        final MessageQueue queue = me.mQueue;        for (;;) {            // 从MessageQueue拿到一个Message，queue.next()里面会阻塞cpu            Message msg = queue.next();            if (msg == null) {                // No message indicates that the message queue is quitting.                return;            }            //省略代码            // msg.target 实际就是 Handler实例，dispatchMessage处理消息            msg.target.dispatchMessage(msg);            //省略代码            msg.recycleUnchecked();        }    }

有两个关键代码：一个 queue.next()，一个 msg.target.dispatchMessage(msg)，先看 Handler.dispatchMessage() 方法：

    public void dispatchMessage(Message msg) {        if (msg.callback != null) {            //如果Message.callback不空，实际也就是有Runnable，那么会直接运行它的run方法；            handleCallback(msg);        } else {            if (mCallback != null) {                // 如果new Handler的时候，传了Callback，会调用Callback.handleMessage                 if (mCallback.handleMessage(msg)) {                    return;                }            }            //Message没有Runnable，Handler没有Callback，或者Callback.handleMessage 返回false，才会调用Handler自己的handleMessage            handleMessage(msg);        }    }

接下来看 MessageQueue.next() 方法：

    Message next() {        for (;;) {            //省略代码            // @1            // native层阻塞cpu            nativePollOnce(ptr, nextPollTimeoutMillis);            //省略代码            synchronized (this) {                final long now = SystemClock.uptimeMillis();                Message prevMsg = null;                Message msg = mMessages;                if (msg != null && msg.target == null) {                    // @2                    // msg.target为空的情况，只有MessageQueue.enqueueSyncBarrier                    // msg.isAsynchronous 只能结合 Barrier 使用，也就是说就算有异步的消息，但是没有设置 Barrier，也是没效果的。                    do {                        prevMsg = msg;                        msg = msg.next;                    } while (msg != null && !msg.isAsynchronous());                }                if (msg != null) {                    if (now < msg.when) {                        // @3                        //有消息，但是还没到时间，最后转到 继续阻塞cpu(也就是上面的注释@1)                        nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);                    } else {                        mBlocked = false;                        if (prevMsg != null) {                            // @4                            // prevMsg不空，mMessages是不会变的，所以如果有Barrier，会始终尝试去拿异步消息(也就是上面的注释@2)                            // 所以记得设置了Barrier，要对应的移除掉它，调用 MessageQueue.removeSyncBarrier                            prevMsg.next = msg.next;                        } else {                            mMessages = msg.next;                        }                        msg.next = null;                        return msg;                    }                } else {                    nextPollTimeoutMillis = -1;                }                //省略代码            }            // @5            // 消息队列空闲的时候，也就是有消息但是还没到时间，或者没有消息的时候，会调用IdleHandler.queueIdle()            // 可以通过 MessageQueue.addIdleHandler方法添加            for (int i = 0; i < pendingIdleHandlerCount; i++) {                final IdleHandler idler = mPendingIdleHandlers[i];                mPendingIdleHandlers[i] = null;                boolean keep = false;                try {                    keep = idler.queueIdle();                } catch (Throwable t) {                }                if (!keep) {                    synchronized (this) {                        mIdleHandlers.remove(idler);                    }                }            }            //省略代码        }    }

为什么 msg.target 为空的情况，只有 MessageQueue.enqueueSyncBarrier？

因为正常上 Handler 的 sendMessage 或者是 Message 的 sendToTarget ，实际最后都是走到

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("MessageQueue", 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;    }

从上面代码就可以看出，正常的 sendMessage 如果 target 为空，会抛出异常的。

反而 MessageQueue.enqueueSyncBarrier：

    int enqueueSyncBarrier(long when) {        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;        }    }

从上面代码可以看出，Barrier也就是个Message，是没有target的。

怎么让 msg.isAsynchronous 呢？

有两种方式：

1，Message的方法setAsynchronous()；

2，Handler的构造方法，可以传入 async 参数；

    public Handler(Handler.Callback callback, boolean async) {        //省略代码        mLooper = Looper.myLooper();        mQueue = mLooper.mQueue;        mCallback = callback;        mAsynchronous = async;    }

    private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {        msg.target = this;        if (mAsynchronous) {            // Handler的sendMessage 会把 msg 赋值成 Asynchronous            msg.setAsynchronous(true);        }        return queue.enqueueMessage(msg, uptimeMillis);    }

总结：

1，消息队列循环执行，不一定是完全按照时间串行执行的，是可以有异步消息的。

2，异步消息必须结合 Barrier 使用，也就是说就算有异步消息，但是没有设置 Barrier，也是没效果的。

3，设置了Barrier，要对应的移除掉它，否则同步消息再也不会被处理。

更多相关文章

随机推荐