Android异步消息处理机制实现原理详解

static final ThreadLocal sThreadLocal = new ThreadLocal();
  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<&＃63; 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 sThreadLocal = new ThreadLocal();//这是在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不为空，则执行Runnable的run方法
      handleCallback(msg);
    } else {
      if (mCallback != null) {//如果handler的内置接口类Callback不为空，则执行boolean handleMessage(Message msg)这个方法
        if (mCallback.handleMessage(msg)) {执行完成则return
          return;
        }
      }
      handleMessage(msg);//最后才执行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("<<<<
            var cpro_id = "u6885494";