Android MessageQueue源码分析

Android应用开发中离不开Handler，而Handler实际上最终是将Message交给MessageQueue。MessageQueue是Android消息机制的核心，熟悉MessageQueue能够帮助我们更清楚详细地理解Android的消息机制。这篇文章会介绍MessageQueue消息的插入(enqueueMessage)和读取(next)，native层的消息机制，以及IdleHandler和SyncBarrier的逻辑原理。源码是基于6.0。

MessageQueue的next与enqueueMessage方法

MessageQueue enqueueMessage

每次使用Handler发送一个Message的时候，最终会先调用MessageQueue的enqueueMessage方法将Message方法放入到MessageQueue里面。先看Handler的sendMessage方法，其他发送Message的内容也是一样的:

public final boolean sendMessage(Message msg)
{
   return sendMessageDelayed(msg, 0); // 调用下面这个方法
}



public final boolean sendMessageDelayed(Message msg, long delayMillis)
{
   if (delayMillis < 0) {
       delayMillis = 0;
   }
   return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis); // 调用下面方法
}



public boolean sendMessageAtTime(Message msg, long uptimeMillis) {
   MessageQueue queue = mQueue; //Handler中的mQueue
   if (queue == null) {
       RuntimeException e = new RuntimeException(
               this + " sendMessageAtTime() called with no mQueue");
       Log.w("Looper", e.getMessage(), e);
       return false;
   }
   return enqueueMessage(queue, msg, uptimeMillis); // 下面方法
}



private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
   msg.target = this;
   if (mAsynchronous) {
       msg.setAsynchronous(true);
   }
   return queue.enqueueMessage(msg, uptimeMillis); //调用MessageQueue的enqueueMessage
}

最后会调用Handler的mQueue的enqueueMessage方法，而Handler的mQueue是从哪里来的呢？在Handler的构造函数中设置的，看默认的情况:

public Handler() {
   this(null, false);
}

public Handler(Callback callback, boolean async) {
   if (FIND_POTENTIAL_LEAKS) {
       final Class<? extends Handler> klass = getClass();
       if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) &&
               (klass.getModifiers() & Modifier.STATIC) == 0) {
      
           Log.w(TAG, "The following Handler class should be static or leaks might occur: " +
               klass.getCanonicalName());
       }
   }

   mLooper = Looper.myLooper();
   if (mLooper == null) {
       throw new RuntimeException(
           "Can't create handler inside thread that has not called Looper.prepare()");
   }
   mQueue = mLooper.mQueue;
   mCallback = callback;
   mAsynchronous = async;
}

无参Handler构造函数对应的是当前调用无参Handler构造函数线程的Looper，Looper是一个ThreadLocal变量，也就是说但是每个线程独有的，每个线程调用了Looper.prepare方法后，就会给当前线程设置一个Looper:

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

Looper里面包含了一个MessageQueue, 在Handler的构造函数中，会将当前关联的Looper的MessageQueue赋值给Handler的成员变量mQueue，enqueueMessage的时候就是调用该mQueue的enqueueMessage。关于Handler与Looper可以理解为每个Handler会关联一个Looper，每个线程最多只有一个Looper。Looper创建的时候会创建一个MessageQueue，而发送消息的时候，Handler就会通过调用mQueue.enqueueMessage方法将Message放入它关联的Looper的MessageQueue里面。介绍了Handler与Looper，然后继续看看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(TAG, 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;
}

整个enqueueMessage方法的过程就是先持有MessageQueue.this锁，然后将Message放入队列中，放入队列的过程是：

1. 如果队列为空，或者当前处理的时间点为0（when的数值，when表示Message将要执行的时间点），或者当前Message需要处理的时间点先于队列中的首节点，那么就将Message放入队列首部，否则进行第2步。

2. 遍历队列中Message，找到when比当前Message的when大的Message，将Message插入到该Message之前，如果没找到则将Message插入到队列最后。

3. 判断是否需要唤醒，一般是当前队列为空的情况下，next那边会进入睡眠，需要enqueue这边唤醒next函数。后面会详