Handler 源码解析

// quitAllowed: 是否可以退出, MainLooper 的时候是 false, 其他时候是 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 构造函数，新建消息队列
private Looper(boolean quitAllowed) {
    mQueue = new MessageQueue(quitAllowed);
    mThread = Thread.currentThread();
}

public final class MessageQueue {
  
  MessageQueue(boolean quitAllowed) {
    mQuitAllowed = quitAllowed;
    mPtr = nativeInit();
  }
  
}

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

public static void loop() {
  final Looper me = myLooper(); // 获得当前线程的 looper
  ...
  final MessageQueue = me.mQueue; // 获得消息队列
  ...
  for(;;) {
    Message msg = queue.next(); // 当前没有消息时，该方法会阻塞
    if(msg == null) {
      return; // 返回 null 说明消息队列正在退出
    }
    // 日志
    final Printer logging = me.mLogging;
    if (logging != null) {
        logging.println(">>>>> Dispatching to " + msg.target + " " +
                msg.callback + ": " + msg.what);
    }
    ...
    try{
      msg.target.dispatchMessage(msg); // 分发消息
    } finally {
      ...
    }
    ...
    // 日志
    if (logging != null) {
        logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);
    }
    ...
    // 回收消息到消息池以便复用，调用 `Message.obtain()` 会优先从消息池中取对象
    msg.recycleUnchecked(); 
  }
}

public void dispatchMessage(@NonNull Message msg) {
    if (msg.callback != null) {
        // 优先执行 msg.callback
        handleCallback(msg);
    } else {
        // 优先执行 Handler 的全局 callback
        if (mCallback != null) {
            // 返回 true 的话，不再继续分发到 handleMessage
            if (mCallback.handleMessage(msg)) {
                return;
            }
        }
        // 最后才执行 Handler 本身的 handleMessage
        handleMessage(msg);
    }
}

Message next() {
  ...
  // poll 的时候超时时间，0就是不阻塞，-1 就是无限期阻塞，其他就是超时时间
  int nextPollTimeoutMillis = 0;
  for(;;) {
    // 阻塞，到时间或者队列被唤醒，都会返回
    nativePollOnce(ptr, nextPollTimeoutMillis);
    synchronized (this) {
      Message prevMsg = null;
      Message msg = mMessages;
      // 如果调用过 postSyncBarrier 方法，设置了同步屏障，那么就直接取异步消息
      if(msg != null && msg.target == null) {
        // 取第一个异步消息
        do {
            prevMsg = msg;
            msg = msg.next;
        } while (msg != null && !msg.isAsynchronous());
      }
      // 假如取到了消息
      if(msg != null) {
        // 还没到时间，需要延时，计算要延时多久
        if(now < msg.when) {
          nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);
        }
        // 到时间了，直接取出 msg 返回就行
        else {
          if (prevMsg != null) {
              prevMsg.next = msg.next;
          } else {
              mMessages = msg.next;
          }
          msg.next = null;
          msg.markInUse();
          return msg;
        }
      } 
      // 没有消息，下次就开始无限期阻塞
      else {
        nextPollTimeoutMillis = -1;
      }
      // 正在退出，返回 null
      if(mQuitting) {
        dispose();
        return null;
      }
      // 之后还会执行 idleHandler
      ...
    }
  }
}

public static Message obtain() {
    synchronized (sPoolSync) {
      	// 如果消息池内有对象，那么复用
        if (sPool != null) {
            Message m = sPool;
            sPool = m.next;
            m.next = null;
            m.flags = 0;
            sPoolSize--;
            return m;
        }
    }
    return new Message();
}

public final boolean sendMessage(@NonNull Message msg) {
    return sendMessageDelayed(msg, 0);
}

public final boolean sendMessageDelayed(@NonNull Message msg, long delayMillis) {
    if (delayMillis < 0) {
       delayMillis = 0;
    }
    return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
}

public boolean sendMessageAtTime(@NonNull Message msg, long uptimeMillis) {
    MessageQueue queue = mQueue;
    ...
    return enqueueMessage(queue, msg, uptimeMillis);
}

// 注意这里的时间，只有通过 sendMessageAtFrontOfQueue 方法传入的才会是 0
private boolean enqueueMessage(@NonNull MessageQueue queue, @NonNull Message msg,
            long uptimeMillis) {
    msg.target = this;
    msg.workSourceUid = ThreadLocalWorkSource.getUid();
		// 异步消息，final变量，构造的时候就要传入
    if (mAsynchronous) {
        msg.setAsynchronous(true);
    }
    return queue.enqueueMessage(msg, uptimeMillis);
}

boolean enqueueMessage(Message msg, long when) {
  // 同步屏障消息不是这个方法
  if (msg.target == null) {
      throw new IllegalArgumentException("Message must have a target.");
  }
  ...
  synchronized (this) {
    // 退出了，直接回收消息
    if(mQuitting) {
      msg.recycle();
      return false;
    }
    ...  
    Message p = mMessages;
    boolean needWake;
    // 如果队列为空、消息时间为 0、或者比队列头的时间还早，直接插入到队列头
    // 注意这里消息时间为 0，只有调用 `sendMessageAtFrontOfQueue` 方法才会是 0
    if (p == null || when == 0 || when < p.when) {  
        msg.next = p;
        mMessages = msg;
      	// 是否需要唤醒取决于当前是不是被 block 了
        needWake = mBlocked;
    }
    else {
      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;
      prev.next = msg;
    }
    if (needWake) {
      	// 唤醒 looper 对应的线程
        nativeWake(mPtr);
    }
  }
}

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

public void removeIdleHandler(@NonNull IdleHandler handler) {
    synchronized (this) {
        mIdleHandlers.remove(handler);
    }
}

Message next() {
  ...
  int pendingIdleHandlerCount = -1;
  for(;;) {
    synchronized(this) {
      // 如果这里没有取到想要的 Message
      ...
      // 如果是第一次进入循环，且没有消息 或者 第一个消息都还没到执行的时间 
      // 也就是说，假如当前有同步屏障消息，是不会调用 IdleHandler 的  
      if (pendingIdleHandlerCount < 0
              && (mMessages == null || now < mMessages.when)) {
          pendingIdleHandlerCount = mIdleHandlers.size();
      }
      // 不执行，那就阻塞
      if (pendingIdleHandlerCount <= 0) {
          mBlocked = true;
          continue;
      }
      if (mPendingIdleHandlers == null) {
          mPendingIdleHandlers = new IdleHandler[Math.max(pendingIdleHandlerCount, 4)];
      }
      mPendingIdleHandlers = mIdleHandlers.toArray(mPendingIdleHandlers);
    }
    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) {
          Log.wtf(TAG, "IdleHandler threw exception", t);
      }

      // 如果返回的是 false，那么删除
      if (!keep) {
          synchronized (this) {
              mIdleHandlers.remove(idler);
          }
      }
    }
    
    // 把 count 设置为 0，这样进入下次循环的时候，就不会再次执行 IdleHandler
    // 每调用一次 next 方法最多只会执行一次
    pendingIdleHandlerCount = 0;
    // 为了防止执行 IdleHandler 过程中有消息来，所以这次 poll 不阻塞
    nextPollTimeoutMillis = 0;
  }
}

// 这个就是屏障消息的 token
private int mNextBarrierToken;

public int postSyncBarrier() {
    return postSyncBarrier(SystemClock.uptimeMillis());
}

private int postSyncBarrier(long when) {
    synchronized (this) {
        final int token = mNextBarrierToken++;
        final Message msg = Message.obtain();
        msg.markInUse();
        msg.when = when;
        msg.arg1 = token;
        
        // 可以看到，屏障消息的插入，也是需要查找的
        // 比如当前队列有通过 Handler::sendMessageAtFrontOfQueue 方法插入的消息，也就是 when = 0 的消息
        // 那屏障消息就得在这个消息后面
        Message prev = null;
        Message p = mMessages;
        if (when != 0) {
            while (p != null && p.when <= when) {
                prev = p;
                p = p.next;
            }
        }
        if (prev != null) {
            msg.next = p;
            prev.next = msg;
        } else {
            msg.next = p;
            mMessages = msg;
        }
        return token;
    }
}

public void removeSyncBarrier(int token) {
    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 (needWake && !mQuitting) {
            nativeWake(mPtr);
        }
    }
}

Message next() {
  ...
  for(;;) {
    ...
    synchronized (this) {
      Message prevMsg = null;
      Message msg = mMessages;
      // 如果队列头是同步屏障消息，那么就直接取异步消息
      if(msg != null && msg.target == null) {
        // 取第一个异步消息
        do {
            prevMsg = msg;
            msg = msg.next;
        } while (msg != null && !msg.isAsynchronous());
      }
      // 处理消息
      ...
    }
  }
}