public final class ActivityThread {
  public static void main(String[] args) {
    //代码省略
    //1.创建消息循环的Looper
    Looper.prepareMainLooper();

    ActivityThread thread = new ActivityThread();
    thread.attach(false);
    if (sMainThreadHandler == null) {
      sMainThreadHandler = thread.getHandler();
    }
    AsyncTask.init();

    //2.执行消息循环
    Looper.loop();
    throw new RuntimeException("Main thread loop unexpectedly exited");
  }
}

public Handler(Callback callback, boolean async) {
    //代码省略
    //获取Looper
    mLooper = Looper.myLooper();
    if (mLooper == null) {
      throw new RuntimeException(
        "Can't create handler inside thread that has not called Looper.prepare()");
    }
    //获取消息队列
    mQueue = mLooper.mQueue;
  }

  public static @Nullable Looper myLooper() {
    return sThreadLocal.get();
  }

  public static @NonNull MessageQueue myQueue() {
    return myLooper().mQueue;
  }
  public static void prepare() {
    prepare(true);
  }
  //为当前线程设置一个Looper
  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));
  }
  //设置UI线程的Looper
  public static void prepareMainLooper() {
    prepare(false);
    synchronized (Looper.class) {
      if (sMainLooper != null) {
        throw new IllegalStateException("The main Looper has already been prepared.");
      }
      sMainLooper = myLooper();
    }
  }

/**
   * Run the message queue in this thread. Be sure to call
   * {@link #quit()} to end the loop.
   */
  public static void loop() {
    final Looper me = myLooper();
    if (me == null) {
      throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
    }
    //1.获取消息队列
    final MessageQueue queue = me.mQueue;
    //2.死循环，即消息循环
    for (;;) {
      //3.获取消息，可能阻塞
      Message msg = queue.next(); // might block
      if (msg == null) {
        // No message indicates that the message queue is quitting.
        return;
      }
      //4.处理消息
      msg.target.dispatchMessage(msg);
      //回收消息
      msg.recycleUnchecked();
    }
  }

public final class Message implements Parcelable {
  //target处理
  Handler target; 
  //Runnable类型的callback
  Runnable callback;
  //下一条消息，消息队列是链式存储的
  Message next;
}

//消息处理函数，子类覆写
public void handleMessage(Message msg) {
}

private static void handleCallback(Message message) {
    message.callback.run();
  }

//分发消息
public void dispatchMessage(Message msg) {
    if (msg.callback != null) {
      handleCallback(msg);
    } else {
      if (mCallback != null) {
        if (mCallback.handleMessage(msg)) {
          return;
        }
      }
      handleMessage(msg);
    }
  }

 public final boolean post(Runnable r)
  {
    return sendMessageDelayed(getPostMessage(r), 0);
  }

  public String getMessageName(Message message) {
    if (message.callback != null) {
      return message.callback.getClass().getName();
    }
    return "0x" + Integer.toHexString(message.what);
  }

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

public final boolean sendMessage(Message msg)
  {
    return sendMessageDelayed(msg, 0);
  }

new Thread(){
  Handler handler = null;
  public void run () {
    handler = new Handler();
  };
}.start();

public Handler(Callback callback, boolean async) {
    //代码省略
    //获取Looper
    mLooper = Looper.myLooper();
    if (mLooper == null) {
      throw new RuntimeException(
        "Can't create handler inside thread that has not called Looper.prepare()");
    }
    //获取消息队列
    mQueue = mLooper.mQueue;
  }

new Thread(){
  Handler handler = null;
  public void run () {
    //为当前线程创建Looper，并且绑定到ThreadLocal中
    Looper.prepare()
    handler = new Handler();
    //启动消息循环
    Looper.loop();
  };
}.start();