Android 消息处理机制是什么

  /**
   * Initialize the current thread as a looper, marking it as an
   * application's main looper. The main looper for your application
   * is created by the Android environment, so you should never need
   * to call this function yourself. See also: {@link #prepare()}
   * 用来初始化主线程中的Looper,有Android环境调用,不应该有用户调用.
   */
  public static void prepareMainLooper() {
    prepare(false);
    synchronized (Looper.class) {
      if (sMainLooper != null) {
        throw new IllegalStateException("The main Looper has already been prepared.");
      }
      sMainLooper = myLooper();
    }
  }
  
  public static @Nullable Looper myLooper() {
    return sThreadLocal.get();
  }

   /** Initialize the current thread as a looper.
   * This gives you a chance to create handlers that then reference
   * this looper, before actually starting the loop. Be sure to call
   * {@link #loop()} after calling this method, and end it by calling
   * {@link #quit()}.
   * 交给用户自己调用,通过loop()方法开启消息循环.同时当不需要处理消息时，需要手动调用quit()方法退出循环.
   */
  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));
  }

private Looper(boolean quitAllowed) {
    mQueue = new MessageQueue(quitAllowed); //创建消息队列
    mThread = Thread.currentThread();
  }

  /**
   * Run the message queue in this thread. Be sure to call
   * {@link #quit()} to end the loop.
   */
  public static void loop() {
    final Looper me = myLooper();
    if (me == null) {
      throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
    }
    final MessageQueue queue = me.mQueue;

    // Make sure the identity of this thread is that of the local process,
    // and keep track of what that identity token actually is.
    Binder.clearCallingIdentity();
    final long ident = Binder.clearCallingIdentity();

    for (;;) { //开始消息循环
      Message msg = queue.next(); // 在接收消息时有可能阻塞
      if (msg == null) {
        //message为null时,退出消息循环
        return;
      }

      // This must be in a local variable, in case a UI event sets the logger
      final Printer logging = me.mLogging;
      if (logging != null) {...}

      final long slowDispatchThresholdMs = me.mSlowDispatchThresholdMs;

      final long traceTag = me.mTraceTag;
      if (traceTag != 0 && Trace.isTagEnabled(traceTag)) {...}
      final long start = (slowDispatchThresholdMs == 0) ? 0 : SystemClock.uptimeMillis();
      final long end;
      try {
        msg.target.dispatchMessage(msg); //处理消息
        end = (slowDispatchThresholdMs == 0) ? 0 : SystemClock.uptimeMillis();
      } finally {
        if (traceTag != 0) {
          Trace.traceEnd(traceTag);
        }
      }
      if (slowDispatchThresholdMs > 0) {
        final long time = end - start;
        if (time > slowDispatchThresholdMs) {...}
      }

      if (logging != null) {...}

      // Make sure that during the course of dispatching the
      // identity of the thread wasn't corrupted.
      final long newIdent = Binder.clearCallingIdentity();
      if (ident != newIdent) {...}
      msg.recycleUnchecked();
    }
  }

 Message next() {
    final long ptr = mPtr; //与native方法相关,当mPtr为0时返回null,退出消息循环
    if (ptr == 0) {
      return null;
    }

    int pendingIdleHandlerCount = -1; // -1 only during first iteration
    int nextPollTimeoutMillis = 0; //0不进入睡眠,-1进入书面
    for (;;) {
      if (nextPollTimeoutMillis != 0) {
        //处理当前线程中待处理的Binder进程间通信请求
        Binder.flushPendingCommands(); 
      }
      //native方法,nextPollTimeoutMillis为-1时进入睡眠状态
      nativePollOnce(ptr, nextPollTimeoutMillis); 
      synchronized (this) {
        final long now = SystemClock.uptimeMillis();
        Message prevMsg = null;
        Message msg = mMessages;
        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; //更新到睡眠状态
        }

        // Process the quit message now that all pending messages have been handled.
        //消息循环退出
        if (mQuitting) {
          dispose();
          return null;
        }

        // 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.
      //非睡眠状态下处理IdleHandler接口
      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;
    }
  }

void quit(boolean safe) {
    if (!mQuitAllowed) {
      throw new IllegalStateException("Main thread not allowed to quit.");
    }

    synchronized (this) {
      if (mQuitting) {
        return;
      }
      mQuitting = true; //设置退出状态

      //处理消息队列中的消息
      if (safe) {
        removeAllFutureMessagesLocked(); //处理掉所有延时消息
      } else {
        removeAllMessagesLocked(); //处理掉所有消息
      }

      // We can assume mPtr != 0 because mQuitting was previously false.
      nativeWake(mPtr); // 唤醒消息循环
    }
  }

  /**
   * API Level 1
   * 处理掉消息队列中所有的消息
   */
  private void removeAllMessagesLocked() {
    Message p = mMessages;
    while (p != null) {
      Message n = p.next;
      p.recycleUnchecked(); //回收消息资源
      p = n;
    }
    mMessages = null;
  }

  /**
   * API Level 18
   * 处理掉消息队列中所有的延时消息
   */
  private void removeAllFutureMessagesLocked() {
    final long now = SystemClock.uptimeMillis();
    Message p = mMessages;
    if (p != null) {
      if (p.when > now) {
        removeAllMessagesLocked();
      } else {
        Message n;
        for (;;) {
          n = p.next;
          if (n == null) {
            return;
          }
          if (n.when > now) {
            //找出延时消息
            break;
          }
          p = n;
        }
        p.next = null;
        //由于在消息队列中按照消息when(执行时间排序,所以在第一个延时消息后的所有消息都是延时消息)
        do {
          p = n;
          n = p.next;
          p.recycleUnchecked(); //回收消息资源
        } while (n != null);
      }
    }
  }

public Handler(Callback callback, boolean async) {
    if (FIND_POTENTIAL_LEAKS) {
      final Class<&#63; 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(); //获取Looper对象
    if (mLooper == null) {...}
    mQueue = mLooper.mQueue; //获取消息队列
    mCallback = callback;
    mAsynchronous = async;
  }

  public boolean sendMessageAtTime(Message msg, long uptimeMillis) {
    MessageQueue queue = 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);
  }

boolean enqueueMessage(Message msg, long when) {
    // Handler为null
    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;
  }

 /**
   * Handle system messages here.
   */
  public void dispatchMessage(Message msg) {
    // 消息Callback接口不为null,执行Callback接口
    if (msg.callback != null) {
      handleCallback(msg);
    } else {
      if (mCallback != null) {
        //Handler Callback接口不为null,执行接口方法
        if (mCallback.handleMessage(msg)) {
          return;
        }
      }
      handleMessage(msg); //处理消息
    }
  }

public static void main(String[] args) {
    ...
    ...
    ...
    Looper.prepareMainLooper();

    ActivityThread thread = new ActivityThread();
    thread.attach(false); //建立Binder通道 (创建新线程),与ActivityManagerService建立链接

    if (sMainThreadHandler == null) {
      sMainThreadHandler = thread.getHandler();
    }
    ...
    ...
    ...
    Looper.loop();

    throw new RuntimeException("Main thread loop unexpectedly exited");
  }