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

private static void prepare(boolean quitAllowed) {
  if (sThreadLocal.get() != null) { // 查看是否有l(wèi)ooper與當(dāng)前線程對應(yīng)
    throw new RuntimeException("Only one Looper may be created per thread");
  }
  sThreadLocal.set(new Looper(quitAllowed));
}

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;
 // 略
  for (;;) {
    Message msg = queue.next(); // might block
    if (msg == null) { // 當(dāng)沒有消息的時(shí)候，退出
      // No message indicates that the message queue is quitting.
      return;
    }
// 略
    msg.target.dispatchMessage(msg);
  }

public static void prepareMainLooper() {
  prepare(false); // 創(chuàng)建一個(gè)Looper
  synchronized (Looper.class) {
    if (sMainLooper != null) {
      throw new IllegalStateException("The main Looper has already been   prepared.");
    }
    sMainLooper = myLooper();
  }
}

public static void main(String[] args) {
 // 略
  Process.setArgV0("<pre-initialized>");
 Looper.prepareMainLooper();
 // 略
 ActivityThread thread = new ActivityThread();
 thread.attach(false);
 // 略
 if (sMainThreadHandler == null) {
  sMainThreadHandler = thread.getHandler();
 }

 // 略
 Looper.loop();
 throw new RuntimeException("Main thread loop unexpectedly exited");
 }
}

// 1、自動獲取
public Handler(Callback callback, boolean async) {
 // 略
  mLooper = Looper.myLooper(); // 取出當(dāng)前線程中的Looper
  if (mLooper == null) {
    throw new RuntimeException(
      "Can't create handler inside thread that has not called    Looper.prepare()");
  }
  mQueue = mLooper.mQueue; // 取出MessageQueue
  mCallback = callback;
  mAsynchronous = async;
}
// 2、傳遞一個(gè)Looper進(jìn)來
public Handler(Looper looper, Callback callback, boolean async) {
    mLooper = looper;
    mQueue = looper.mQueue;
    mCallback = callback;
    mAsynchronous = async;
  }

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

/*package*/ Runnable callback;

public int arg1; 

public int arg2;

public Object obj;

/*package*/ Handler target; // 關(guān)鍵點(diǎn)

private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
  msg.target = this; // 賦值語句
  if (mAsynchronous) {
    msg.setAsynchronous(true);
  }
  return queue.enqueueMessage(msg, uptimeMillis);
}

public final Message obtainMessage(){
  return Message.obtain(this);
}