【17】Android 线程间通信(二) - Handler

概述

记得上篇文章我们留下的问题吗？如果还没有看过上一篇讲解Handler基本原理文章的同学可以补一下知识。Android 线程间通信(一) - Handler

回到正题，这次我们将一下上一篇文章留下问题中的几个，idleHandler & syncBarrier。

同步屏障

首先我们了解吗，我们平时通过Handler#sendMessage发送的属于什么消息？同步消息还是异步消息。既然这次讲到同步屏障，我们也可以大胆的猜想，我们平时发送的消息是同步消息，只有特殊情况下，插入这个同步屏障，才会走特殊的异步方式。
如果能够这样推导，说明在Handler这一块的了解已经比较深刻了。我们继续看一下源码。

	//MessageQueue.java     @UnsupportedAppUsage     Message next() {         ...         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;                 //(1) msg不为空，且msg.target为空才会进入                 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;                 } 		...     } 

我们看代码中(1)注解的位置，msg不为空这个很好理解，消息需要有实体，但是target为空这个是为什么呢？上一片文章讲过，msg的target其实就是Handler。而下面官方的注解说明，被栏栅挡住了，在队列中查找下一个异步消息。然后开始从当前这个msg的下一个msg开始查找，知道下一个消息属于异步消息或者查找直到为空位置，跳出循环。

可见挡住同步消息的，正是这个msg.target=null的消息，那么它是怎么插入进来的呢？我们接着看。

	//MessageQueue.java 	     @UnsupportedAppUsage     @TestApi     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;         }     } 

MessageQueue中有一个方法叫做postSyncBarrier，可以理解为插入同步屏障。首先通过Message#obtain获取消息，这里是对消息对象的一个复用，在消息处理完之后，会把Message的target清除。然后标记为使用，接着就是消息的一些属性赋值，但唯独没有重新确定msg的target对象。可见如果messageQueue需要插入同步屏障，就是通过这个方法把屏障消息插入进去的。

插入同步屏障消息是直接通过MessageQueue进行插入

既然有插入同步屏障，那么也有移除屏障，让同步消息可以继续执行。

	//MessageQueue.java     @UnsupportedAppUsage     @TestApi     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);             }         }     } 

还有个问题，就是同步屏障是挡住同步消息，那么怎么发送异步消息呢？我们看看Message的源码。

	// Message.java     public void setAsynchronous(boolean async) {         if (async) {             flags |= FLAG_ASYNCHRONOUS;         } else {             flags &= ~FLAG_ASYNCHRONOUS;         }     } 

有一个设置异步的方法，根据传入的bool值，flags和标志位做位运算。我们只要了解，当async为true，flags = 1，async为false，flags = 0。之前跳出next中的do…while循环中，判断异步消息的方式，就是msg#isAsynchironous。也就是说，setAsynchronous当传入true的时候，判断消息的条件就为真，此时发送的消息就是异步消息了。

	//Message.java     public boolean isAsynchronous() {         return (flags & FLAG_ASYNCHRONOUS) != 0;     } 

默认情况下flags = 0，为同步消息

这样一来，同步屏障的作用和使用方式，我们就彻底搞懂了。

IdleHandler

空闲Handler，和字面意思一样。Handler是消息处理的句柄，那么IdleHandler，就是处理空闲消息的句柄。在MessageQueue#next源码中，我们继续看一下。

	//MessageQueue#next                 // 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;         } 

next方法下面有这样一段代码，什么时候会执行下去呢？就是当msg=null的时候，因为当msg不为空，说明取出了msg，并返回给Looper进行后续分发了。msg为null，说明此时消息队列中取不出消息了，就会从mIdlehandlers这个集合中，获取集合大小，并且把集合转换成数组mPendingIdleHandlers。

接着通过一个for循环，取出每一个idler并执行它的queueIdle，这个queueIdle是一个接口，可见是一个接口回调的操作，回调给用户去操作了。

	//MessageQueue.java     public void addIdleHandler(@NonNull IdleHandler handler) {         if (handler == null) {             throw new NullPointerException("Can't add a null IdleHandler");         }         synchronized (this) {             mIdleHandlers.add(handler);         }     } 

通过MessageQueue的addIdleHandler接口，我们可以向MessageQueue维护的集合中添加这种空闲Handler，当消息队列MessageQueue的消息队列中没有任务可以执行之后，就会执行这些空闲的消息。

可以发现，IdleHandler适合处理那些优先级比较低的事情，而不会影响到用户界面的响应性。避免在主线程繁忙的时候执行耗时任务，从而保持应用的流畅性。

总结

1、MessageQueue可以发送同步屏障消息
2、Message可以通过设置确认发送的消息为同步还是异步
3、同步屏障消息的Handler为空
4、MessageQueue可以添加IdleHandler来处理优先级较低的任务

这下应用层Handler的东西我们都了解了。下一篇文章接下来将通过native层来分析一下Handler这个线程间通信的方式，底层到底还做了什么。