Android Handlerソースコードの正しい姿勢をアーキテクチャの観点から分析する

/**

• ： Looper.loop()
• ： ， 、 Handler
• ：
• a. ，

• b. ： MessageQueue quit（）
  */
  public static void loop() {

  ...//        
  
  // 1.     Looper     
      final Looper me = myLooper();
      if (me == null) {
          throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
      }
      // myLooper()  ：  sThreadLocal   Looper  ； me null      
      //  loop（）       prepare（），    1 Looper  
  
      final MessageQueue queue = me.mQueue;
      //   Looper          （MessageQueue）
  
  // 2.     （  for  ）
      for (;;) {
  
      // 2.1           
      Message msg = queue.next(); 
      if (msg == null) {
          return;
      }
      // next()：          
      //         ，     
      // ->>   1 
  
      // 2.2         Handler
      msg.target.dispatchMessage(msg);
      //    Message       msg target  
      // target     1 handler  
      // ->>  2
  
  // 3.          
  msg.recycle();
  }

  }

/**

• 1：queue.next()
• ： （MessageQueue）

• ： ，
  */
  Message next() {

  ...//        
  
  //                   
  //                   or     
  int nextPollTimeoutMillis = 0;
  
  for (;;) {
      if (nextPollTimeoutMillis != 0) {
          Binder.flushPendingCommands();
      }
  
  // nativePollOnce   native ，  nextPollTimeoutMillis -1，            　
  nativePollOnce(ptr, nextPollTimeoutMillis);
  
  synchronized (this) {
  
      final long now = SystemClock.uptimeMillis();
      Message prevMsg = null;
      Message msg = mMessages;
  
      //     ，            ：   Message       
      if (msg != null) {
          if (now < msg.when) {
              nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);
          } else {
              //      
              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 {
  
          //            ，  nextPollTimeoutMillis    -1
          //      ，           
          nextPollTimeoutMillis = -1;
      }
  
      ......
  }
     .....

  }
  }//

/**

• 2：dispatchMessage(msg)
• ： （Handler）

• ： Handler & msg
  */
  public void dispatchMessage(Message msg) {

  // 1. msg.callback ， post（Runnable r）
  // handleCallback(msg)， Runnable run（）
  // “post（Runnable r）”
  if (msg.callback != null) {
  handleCallback(msg);
  } else {
  if (mCallback != null) {
  if (mCallback.handleMessage(msg)) {
  return;
  }
  }

      // 2.  msg.callback    ，      sendMessage（Message msg）    （       ）
      //    handleMessage(msg)，      handleMessage(msg) ->>   3
      handleMessage(msg);
  
  }

  }

  /**

  • 3：handleMessage(msg)

  • ： = ， Handler =
    **/
    public void handleMessage(Message msg) {
    ... // Handler
    }

    
    ###   ：

• = + Handler

• Handler ： dispatchMessage(msg)handleMessage(Message msg)を して し、 には き みのmsg.callbackをコールバックしてメッセージ の

を する
• に :メッセージ

（dispatchMessage(msg)）


、1 の の が われます.post（Runnable r） が でなければ、Runnableを してメッセージを したことを し、 コールバックrun（） に されたmsg.callback が であれば、sendMessage（Message msg）を してメッセージを したことを す.
2:メッセージ・オブジェクトの

/** 
  *     
  */
    Message msg = Message.obtain(); //        
    msg.what = 1; //     
    msg.obj = "AA"; //       

/** 
  *     ：Message.obtain()
  *   ：      
  *  ：  Message       new   Message.obtain()
  */
  public static Message obtain() {

        // Message     1 Message ，  Message       
        //   obtain（）         
        synchronized (sPoolSync) {
            if (sPool != null) {
                Message m = sPool;
                sPool = m.next;
                m.next = null;
                m.flags = 0; // clear in-use flag
                sPoolSize--;
                return m;
            }
            //   ：  obtain（）”  “    ，       new      
        }
        //            ，       new  
        return new Message();

    }

    ###   3：                 


マルチスレッドの :handleMessage(msg), Threadクラス, AsyncTask

/** 
  *     
  */

    mHandler.sendMessage(msg);

/** 
  *     ：mHandler.sendMessage(msg)
  *   ：      （Handler）   
  *   ：             （Message ->> MessageQueue）
  */
  public final boolean sendMessage(Message msg)
    {
        return sendMessageDelayed(msg, 0);
        // ->>  1
    }

         /** 
           *   1：sendMessageDelayed(msg, 0)
           **/
           public final boolean sendMessageDelayed(Message msg, long delayMillis)
            {
                if (delayMillis < 0) {
                    delayMillis = 0;
                }

                return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
                // ->>   2
            }

         /** 
           *   2：sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis)
           **/
           public boolean sendMessageAtTime(Message msg, long uptimeMillis) {
                    // 1.            （MessageQueue）
                    MessageQueue queue = mQueue;

                    // 2.    enqueueMessage   ->>  3
                    return enqueueMessage(queue, msg, uptimeMillis);
                }

         /** 
           *   3：enqueueMessage(queue, msg, uptimeMillis)
           **/
            private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
                 // 1.  msg.target   this
                 //   ：     Handler      msg target  
                 msg.target = this;
                 //         Looper loop()      ，             msg，    msg.target.dispatchMessage(msg)     
                 //                Handler          

                // 2.        enqueueMessage（）
                //  ：Handler     ，          ->>  4
                return queue.enqueueMessage(msg, uptimeMillis）;
        }

        /** 
          *   4：queue.enqueueMessage(msg, uptimeMillis）
          *   ：       （MessageQueue）   
          *   ：  ，                   （Message ->> MessageQueue）
          *        ：      、       
          */
          boolean enqueueMessage(Message msg, long when) {

                ...//        

                synchronized (this) {

                    msg.markInUse();
                    msg.when = when;
                    Message p = mMessages;
                    boolean needWake;

                    //            
                        // a.   ，               &              ，   
                        if (p == null || when == 0 || when < p.when) {
                            msg.next = p;
                            mMessages = msg;
                            needWake = mBlocked;
                        } else {
                            needWake = mBlocked && p.target == null && msg.isAsynchronous();
                            Message prev;

                        // b.           ，      （Message）            
                            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) {
                            nativeWake(mPtr);
                        }
                    }
                    return true;
            }

//   ，  Looper         
//           Handler      &      Handler
//     Handler.handleMessage()    


(より くの なプロジェクトがダウンロードされています. は きます.ソースコード. の はgithubをアップロードします.)Runnable