static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
  private static Looper sMainLooper; // guarded by Looper.class

  final MessageQueue mQueue;
  final Thread mThread;

final MessageQueue mQueue;
  final Looper mLooper;
  final Callback mCallback;
  final boolean mAsynchronous;
  IMessenger mMessenger;

public Handler() {
    this(null, false);
  }
public Handler(Callback callback) {
    this(callback, false);
  }
public Handler(Looper looper) {
    this(looper, null, false);
  }
 public Handler(Looper looper, Callback callback) {
    this(looper, callback, false);
  }
 public Handler(boolean async) {
    this(null, async);
  }
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();
    if (mLooper == null) {
      throw new RuntimeException(
        "Can't create handler inside thread that has not called Looper.prepare()");
    }
    mQueue = mLooper.mQueue;
    mCallback = callback;
    mAsynchronous = async;
  }
 public Handler(Looper looper, Callback callback, boolean async) {
    mLooper = looper;
    mQueue = looper.mQueue;
    mCallback = callback;
    mAsynchronous = async;
  }

static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();//這是在Looper類中的定義
public static Looper myLooper() {
    return sThreadLocal.get();//從當前線程中獲得looper對象
  }
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));//為當前線程設置looper對象
}

Looper.javaprivate Looper(boolean quitAllowed) {
    mQueue = new MessageQueue(quitAllowed);
    mRun = true;
    mThread = Thread.currentThread();
  }MessageQueue.java
// True if the message queue can be quit.  private final boolean mQuitAllowed;//true消息隊列可以被quit，false消息隊列不能被quit。

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 void dispatchMessage(Message msg) {
    if (msg.callback != null) {//如果msg有綁定callback回調接口Runaable不為空，則執(zhí)行Runnable的run方法
      handleCallback(msg);
    } else {
      if (mCallback != null) {//如果handler的內置接口類Callback不為空，則執(zhí)行boolean handleMessage(Message msg)這個方法
        if (mCallback.handleMessage(msg)) {執(zhí)行完成則return
          return;
        }
      }
      handleMessage(msg);//最后才執(zhí)行handler本身的方法
    }
  }
 private static void handleCallback(Message message) {    message.callback.run();  }
public interface Callback {//handler的內置接口類Callback
public boolean handleMessage(Message msg);
  }

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;//給msg的target賦值為handler自身然后加入MessageQueue中
    if (mAsynchronous) {
      msg.setAsynchronous(true);
    }
    return queue.enqueueMessage(msg, uptimeMillis);
  }

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(); // might block
      if (msg == null) {
        // No message indicates that the message queue is quitting.
        return;
      }

      // This must be in a local variable, in case a UI event sets the logger
      Printer logging = me.mLogging;
      if (logging != null) {
        logging.println(">>>>> Dispatching to " + msg.target + " " +
            msg.callback + ": " + msg.what);
      }

      msg.target.dispatchMessage(msg);

      if (logging != null) {
        logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);
      }

      // Make sure that during the course of dispatching the
      // identity of the thread wasn't corrupted.
      final long newIdent = Binder.clearCallingIdentity();
      if (ident != newIdent) {
        Log.wtf(TAG, "Thread identity changed from 0x"
            + Long.toHexString(ident) + " to 0x"
            + Long.toHexString(newIdent) + " while dispatching to "
            + msg.target.getClass().getName() + " "
            + msg.callback + " what=" + msg.what);
      }

      msg.recycle();
    }
  }