Android Handler原始碼深入探究

      public static void main(String[] args) {
          //建立一個訊息迴圈
          Looper.prepareMainLooper();
          //建立ActivityThread物件
          ActivityThread thread = new ActivityThread();
          //建立Application、啟動MainActivity
          thread.attach(false, startSeq);
          //使訊息迴圈奔跑起來
          Looper.loop();
          //拋了一個異常 主執行緒的Looper 意外退出了，
          //所以loop中的for迴圈要阻塞在這裡，一旦main函數執行完畢，程序也就退出了。
          //並且一直要提取訊息，處理訊息。
          throw new RuntimeException("Main thread loop unexpectedly exited");
      }

 Looper.prepareMainLooper();
    public static void prepareMainLooper() {
        prepare(false);
        //同步方法保證一個sMainLooper 只被賦值一次。
        synchronized (Looper.class) {
            if (sMainLooper != null) {
                throw new IllegalStateException("The main Looper has already been prepared.");
            }
            sMainLooper = myLooper();
        }
    }
    //建立一個Looper物件，並儲存在了 sThreadLocal中。關於ThreadLocal，也是很重要的一個知識點。
     private static void prepare(boolean quitAllowed) {
        //一個執行緒只能有一個Looper，
        if (sThreadLocal.get() != null) {
            throw new RuntimeException("Only one Looper may be created per thread");
        }
        sThreadLocal.set(new Looper(quitAllowed));
     }
      public static @Nullable Looper myLooper() {
            return sThreadLocal.get();
      }
   //在Looper中建立了MessageQueue
   private Looper(boolean quitAllowed) {
        mQueue = new MessageQueue(quitAllowed);
        mThread = Thread.currentThread();
   }

 Looper.loop();
    /**
    * Run the message queue in this thread.
    */
     public static void loop() {
        for (; ; ) {
            //從訊息迴圈中提取訊息。訊息時會阻塞在這裡。
            Message msg = queue.next(); // might block
            //target-->Handler.Msg持有handler的參照。
            msg.target.dispatchMessage(msg);
        }
    }

 插入訊息
    //Message.obtain()從Message訊息快取池內獲得一個訊息。
    handler.sendMessage(Message.obtain());
    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;
           return enqueueMessage(queue, msg, uptimeMillis);
    }
     private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
            //this==handler,在這裡給message.target賦值了handler。
            msg.target = this;
            if (mAsynchronous) {
                msg.setAsynchronous(true);
            }
            return queue.enqueueMessage(msg, uptimeMillis);
     }

     //在MessageQueue中用一個單線連結串列來儲存訊息。
     //在這個訊息的單連結串列中，是按訊息執行的時間先後，從小到大排序的。
     //mMessages 是這個單連結串列的第一個訊息。
     boolean enqueueMessage(Message msg, long when) {
          //通過sendMessage並不能傳送handler==null的訊息。
         if (msg.target == null) {
              throw new IllegalArgumentException("Message must have a target.");
          }
         synchronized (this) {
             msg.markInUse();
             msg.when = when;
             //將連結串列中第一個訊息賦值給p
             Message p = mMessages;
             boolean needWake;
             //如果p==null說明訊息列表中沒有要被執行的訊息。
             //如果when==0說明新新新增的訊息要被馬上執行，所以要排在列表的頭部
             //如果when<p.when，說明新新增的訊息，比訊息佇列第一個訊息要先執行，所以也要放在頭部
             if (p == null || when == 0 || when < p.when) {
                 // New head, wake up the event queue if blocked.
                 //將原來的頭部訊息賦值給新訊息的next
                 msg.next = p;
                 //將新加的訊息賦值給mMessage。因為mMessages這個變數用來儲存訊息列表的第一個訊息。
                 mMessages = msg;
             } else {//如果when>=p.when，則需要遍歷訊息佇列，將新新增的訊息插入到佇列中間，
                 Message prev;
                 for (;;) {
                     prev = p;//把當前的賦值給前一個
                     p = p.next;//把下一個賦值給當前的
                     //如果p==null說明已經遍歷到了連結串列末尾。
                     //如果新增的訊息時間小於了p的when。那麼這個訊息應該插入到prev之後，p之前。
                     if (p == null || when < p.when) {
                         break;
                     }
                 }
                 //新增訊息在p之前，prev之後
                 msg.next = p; // invariant: p == prev.next
                 prev.next = msg;
             }
         }
         return true;
   }

  Message next() {
           int nextPollTimeoutMillis = 0;
           for (;;) {
               if (nextPollTimeoutMillis != 0) {
                   Binder.flushPendingCommands();
               }
               //開始休眠，nextPollTimeoutMillis下次被喚醒的時間
               //如果是-1則一直休眠，直到有新的訊息再喚醒訊息佇列。
               nativePollOnce(ptr, nextPollTimeoutMillis);
               synchronized (this) {
                   // Try to retrieve the next message.  Return if found.
                   //開始遍歷訊息佇列，返回找到的訊息。
                   final long now = SystemClock.uptimeMillis();
                   Message prevMsg = null;
                   //訊息佇列，頭部訊息
                  //如果msg！=null,但是msg.target==null,sendMessage中，是不允許傳送handler為null的訊息的。
                   //target==null的訊息是系統傳送的，先傳送一個同步屏障訊息，再傳送直到isAsynchronous = true的非同步訊息。
				   //這樣做的目的就保證了這個非同步訊息有更高優先順序被執行，先從訊息佇列中提取。
                   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());//直到isAsynchronous = true，也就是找到了同步屏障的非同步訊息
                   }
                   }
                   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 {
                               //如果前一個訊息是null，說明當前就是訊息頭，
                               //將訊息佇列頭部訊息指向當前提取出訊息的下一個訊息。
                               mMessages = msg.next;
                           }
                           //將找到的訊息的下一個賦值null，和原來的訊息佇列脫離關係。
                           msg.next = null;
                           if (false) Log.v("MessageQueue", "Returning message: " + msg);
                           return msg;
                       }
                   } else {//如果msg==null
                       // No more messages.
                       nextPollTimeoutMillis = -1;
                   }
               }
           }
       }

  //同步屏障訊息
    void scheduleTraversals() {
        if (!mTraversalScheduled) {
            mTraversalScheduled = true;
            //傳送一個同步屏障訊息
            mTraversalBarrier = mHandler.getLooper().postSyncBarrier();
            mChoreographer.postCallback(
                    Choreographer.CALLBACK_TRAVERSAL, mTraversalRunnable, null);
        }
    }

  Message.obtain()
     private static Message sPool;
     private static final int MAX_POOL_SIZE = 50;
     public static 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;
                }
            }
            return new Message();
      }