(一)MessageQueue之消息入队

public class SimpleNode {
   // 当前链表,
   Node mNode;

   public void insert(Node node) {
       // 1.链表为null,第一次插入
       if (mNode == null) {
           //node作为第一个元素,放入mNode
      } else {
          //2.1 链表不为null,找出最后一个节点
          //2.2 将待插入节点 Node 插入 最后一个节点之后  
      }
  }
   
   //节点
   public class Node {
       int data;
       Node next;

       public Node() {
           this.next = null;
      }
  }    
}

public class SimpleNode {
   // 当前链表
   Node mNode;

   public class Node {
       int data;
       Node next;

       public Node() {
           this.next = null;
      }
  }

   public void insert(Node node) {
       //创建一个临时节点
       Node currentNode = mNode;
       // 1.链表为null,第一次插入
       if (currentNode == null) {
           mNode = node;
      } else {
           // 2.1 遍历链表,找出最后一个节点
           Node realLastNode;
           for (; ; ) {
               realLastNode = currentNode;
               currentNode = currentNode.next;
               //在 for 循环中,如果此时currentNode为 null,说明链表没有节点了,即realLastNode.next为 null,
               //realLastNode就是我们要找的节点,退出 for 循环
               if (currentNode == null) {
                   break;
              }
          }
           //将待插入节点 Node 插入到最后    
           realLastNode.next = node;
      }
  }

}

public final class MessageQueue {
   
   
   boolean enqueueMessage(Message msg, long when) {
       //...
       //同步方法块
       synchronized (this) {
           //...
           msg.when = when;
           Message p = mMessages;
           boolean needWake;
           //1.1 当前mMessages 为 null,队列中没有消息
           //1.2 当前mMessages 不为 null,when == 0说明队列中的消息都是延迟的消息
           //1.3 当前mMessages 不为 null,when < p.when 说明当前消息是延迟消息,但是队列中的消息比我这个消息延迟还大.
           if (p == null || when == 0 || when < p.when) {
               // New head, wake up the event queue if blocked.
               //将当前消息作为mMessages的第一个
               //此时 p 是 null
               msg.next = p;
               //更新mMessages
               mMessages = msg;
               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;
                  }
              }
               //此时 p 是 null
               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;
  }    
   
}