Androidメッセージ処理メカニズムを詳細に説明する。

要約
Androidアプリケーションはメッセージによって駆動され、Androidのメインスレッドが起動すると内部にメッセージキューが作成されます。その後、無限ループに入り、ポーリングは新しいメッセージがあるかどうかを処理する必要がある。新しいニュースがあれば、新しい情報を処理します。メッセージがないと、メッセージが呼び覚まされるまでブロック状態になります。
Androidシステムでは、メッセージ処理の仕組みはどうやって実現されますか？プログラム開発の時、私達はよくHandlerを使ってMessageを処理します。したがって、Handlerはメッセージ処理者であり、Messageはメッセージ主体であることがわかる。他にもメッセージ・キューとメッセージ・ポーリングの2つの役割があります。それぞれMessage QueとLooperで、メッセンジャーQueはメッセージ・キューで、Looperはポーリング・メッセージを担当しています。
概要
Androidのメッセージ・メカニズムは主にHandler、Message、Message Que、Looperの四つの種類の実装によって完成されることをすでに知っています。その関係はどうなりますか？
ここで、Messageはメッセージ本体であり、メッセージを送信するHandlerオブジェクト、メッセージ情報、メッセージ識別子などを含む様々な情報を記憶する。Message Queはメッセージ・キューであり、その内部ではメッセージ・グループをキューで維持する。Handlerはメッセージの送信と処理を担当しています。Looperはポーリングメッセージ・キューを担当しています。

Androidメッセージ構造の原理
スレッドメッセージキューを作成
Androidアプリケーションでは、メッセージ処理プログラムが実行される前にまずメッセージキューを作成します。メインスレッドでは、Looperクラスの静的メンバ関数prepare MainLooper()を呼び出してメッセージキューを作成します。他のサブスレッドでは静的メンバ関数prepare()を呼び出して作成した。
prepare MainLooper（）とprepare（）の実現：

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

この二つの関数が呼び出される過程で、sThreadLocal変数は使用されます。この変数はThreadLocalタイプで、現在のスレッドのLooperオブジェクトを保存します。つまり、Androidアプリケーションでは、メッセージ・キューを作成するごとに、一つずつあります。これに対応する唯一のLooperオブジェクトです。そして、ソースからオブジェクトが唯一でないと異常を投げかけることができます。

private Looper(boolean quitAllowed) {
    mQueue = new MessageQueue(quitAllowed); //      
    mThread = Thread.currentThread();
  }

上のソースコードからは、Looperオブジェクトの実装プロセスを参照することができますし、同時にメッセージのキューを作成します。
メッセージサイクルプロセス
メッセージ・キューの確立が完了すると、Looperオブジェクトの静的なメンバ方法loop（）が起動され、メッセージ・ループが開始される。

  /**
   * 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();
    }
  }

上記のソースコードはニュース循環の過程で、loop（）方法のニュース循環だけを呼び出してから役割を果たします。ループが開始された時:

は、現在のスレッドのLooperオブジェクトを取得し、nullであれば、例外をスローします。

は、メッセージ・キューを取得し、メッセージ・ループに入ることを開始する。

メッセージ・キューからメッセージ（Message Queのnextを呼び出す方法）を取得し、nullであればループを終了する。さもないと実行し続けます。

はメッセージを処理し、メッセージリソース（msg.recycle Unicheced（）を回収する。

メッセージサイクル中にメッセージをMessage Queのnext（）方法で提供し、情報がないときはスリープ状態になり、他のインターフェースを処理する。このプロセスは極めて重要であり、next（）方法によってメッセージサイクルが終了するかどうかも決定される。

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

メッセージループ終了プロセス
上からloop()の方法が見えますが、Message Queのnext()の方法がnullに戻る時にのみループが終了します。MessageQueのnext()の方法はいつnullですか？
ループクラスでは、2つのエンドメソッドquit（）とquit Salely（）を見ました。両者の違いは、quit（）方法がサイクルを直接終了し、MessageQueのすべてのメッセージを処理し、quit Safely（）はメッセージ・キューの中の残りの非遅延メッセージ（遅延メッセージ）を処理し終わった後に終了することである。この2つの方法は、Message Queのquitメソッドを呼び出します。

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

メッセージ・キュー内のメッセージを処理する：safeフラグに従って、異なる処理を選択する。

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

メッセージ送信プロセス
Androidアプリケーションでは、Handlerクラスを介してスレッドのメッセージキューにメッセージを送信します。各Handlerオブジェクトの中にLooperオブジェクトとMessageQueオブジェクトがあります。

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(); //  Looper  
    if (mLooper == null) {...}
    mQueue = mLooper.mQueue; //      
    mCallback = callback;
    mAsynchronous = async;
  }

Handlerクラスでは、様々なsendMessage方法が見られますが、最終的には同じ方法のsendMessage AtTime（）方法が起動されます。

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

これらの2つの方法は、メッセージ・キューにメッセージを追加するために、Message Queオブジェクトを介してenqueueMessageを呼び出す方法であることが分かりやすい。

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

ソースからは、メッセージの列に挿入するには以下の手順が必要です。
メッセージ保有のHandler対象はnullで、異常を投げます。ニュースがすでに消費された時、異常を投げます。
メッセージキューにメッセージがない場合は、直接挿入します。
メッセージキューにメッセージが存在する場合、メッセージの実行時間を比較することによって、メッセージを対応する位置に挿入する。
メッセージループを起動する必要があるかどうかを判断します。
メッセージ処理プロセス
メッセージサイクル中に、新しいメッセージが参加されると、メッセージの処理が開始される。上記の分析からは、メッセージサイクルにおいて、ターゲットメッセージがそのHandlerオブジェクトのdispatch Message（）を呼び出す方法が見られます。これがメッセージを処理する方法です。

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

ソースからは、Handler処理のメッセージを3つの状況に分けることができます。

Messageの中のcalbackがnullでない場合、Messageの中のcalback中の方法を実行します。このcalbackはRunnableコネクタです。

は、HandlerにおけるCallbackインターフェースがnullでないとき、Callbackインターフェースにおける方法を実行する。

は、HandlerにおけるhandleMessage（）方法を直接実行する。

Looperがloop()を起動した時、メインスレッドはなぜ死なないですか？
上の分析を行った後、Looper.loop（）が死のサイクルに入っていることを知っています。このデッドサイクルをメインスレッドで実行すると、なぜメインラインのカードが死に至らなかったのですか？あるいはメインスレッドでの他の操作がスムーズに行われます。例えばUI操作などです。Androidアプリケーションはメッセージによって駆動されるので、Androidアプリケーションの動作もAndroidのメッセージ機構によって実現される。この時はAndroidプログラムが起動する入口類ActivityThreadを分析する必要があります。Androidプログラムが起動された時にJava層にあるのはActivityThreadのmain()メソッドを入口としていることを知っています。これがメインスレッドです。

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

ActivityThreadのmainからLooperの初期化とメッセージサイクルの開始を見ることができます。また、ActivityManagerServiceとリンクして、Activityにおける各種イベントの発生のためにリンクを作成します。ここではNative層Looperの初期化にも言及し、Looper初期化時にメッセージキューの読み書きを維持するためのパイプラインを確立し、epollメカニズムによってイベント（IO多重方式）を傍受する。

新しいメッセージがないと処理が必要になります。新しいメッセージがあるまで、メインスレッドはパイプに詰まります。

他のスレッドからメッセージキューにメッセージが送信されると、パイプを介してデータを書き込みます。

私達がプログラムを調整する時、私達は関数の呼び出しスタックを通してその中の道理を発見することができます。

これはまた、メッセージによって駆動されるAndroidアプリケーションの始まりを実証しています。
すべてのメッセージが指定された時間から実行されるかどうか
この問題の意味は、メッセージ・キューのようにメッセージを送信する場合（例えば、1つのメッセージpostDelay（action，1000）を1000 ms後に実行するかどうかということです。
答えは決まっていません。私たちはAndroidのメッセージだけを時間順にメッセージキューに保存しています。10000個の遅延10000 msの実行メッセージなど、複数のメッセージをキューに追加すると、最後の実行メッセージと最初の実行メッセージの実行時間は違っています。
締め括りをつける
これでAndroidシステムのメッセージ処理メカニズムは分析されました。Androidアプリケーションでは、メッセージ処理は主に3つのプロセスに分けられる。

は、ループ中のメッセージサイクルを開始し、メッセージキューの傍受を開始する。

は、Handlerを介してメッセージ・キューに送信する。

は、Handlerオブジェクトを呼び出して、新たに追加されたメッセージを処理する。

メッセージキューを使用すると、メインスレッドではプログラム起動時にメッセージキューが作成されますので、メインスレッド内のメッセージ機構を使用する場合は、初期化メッセージループとメッセージキューは必要ありません。サブスレッドでは、メッセージキューを初期化し、メッセージキューを使用する必要がないときは、Looperのquitまたはquit Safely方法を直ちに呼び出すべきであり、そうでなければ、サブスレッドは常に待機状態にあるかもしれないことに注意してください。
以上はAndroidメッセージの処理メカニズムの詳細な内容を詳しく説明しました。Androidメッセージの処理メカニズムに関する資料は他の関連記事に注目してください。