前言
Handler 在Android 开发中是使用频率非常高的，所以Android 开发有必要了解Handler 的机制。下面就个人理解简单介绍一下 Handler 原理，在这里我们
需要了解的类
- Handler
- Looper
- Message
- MessageQueue
- ActivityThread
首先要说Looper
Looper 类看名便知其意，循环。看Looper 类源码一定要注意这段代码：
static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
该 ThreadLocal 保存不同线程中的Looper,非常重要。
下面我们在看Looper中的一个 prepare 方法，先看代码，代码如下：
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));
}
在这段代码中看 sThreadLocal.get() 段代码，获取当前线程中Looper 实例，写到这我又看到可下面的异常了，那就让我们看看这个异常是什么：Only one Looper may be created per thread, 意思是：每个线程中只可以创建一个Looper实例。然后我们在看看这个方法的功能，创建自身线程的 Looper 实例，并将Looper 保存在ThreadLocal 中。
在看一下 Looper 中 myLooper() 方法，代码如下：
public static @Nullable Looper myLooper() {
return sThreadLocal.get();
}
代码简单，就是获取所在线程中的Looper 实例。
在看一下 Looper 中 prepareMainLooper() 方法，代码如下：
public static void prepareMainLooper() {
prepare(false);
synchronized (Looper.class) {
if (sMainLooper != null) {
throw new IllegalStateException("The main Looper has already been prepared.");
}
sMainLooper = myLooper();
}
}
该方法主要是获取主线程中的Looper 实例，该方法在 ActivityThread 中main中执行（ActivityThread 类是程序的入口），即在程序的入口创建一个主线程的 Looper 实例。同时，Looper 中还有 getMainLooper() 方法，代码如下：
public static Looper getMainLooper() {
synchronized (Looper.class) {
return sMainLooper;
}
}
这段代码是获取主线程的 Looper 实例。
Looper 有一个非常重要的方法 loop() ，这个方法非常重要，主要是负责从 MessageQueue 中取出消息交给 Handler 在该线程中执行，写到这里，可能会有些蒙，MessageQueue 在什么时候被实例的，看下面这段代码就知道了：
private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}
在Looper 的一个构造方法中MessageQueue被实例。
下面就要介绍一下 loop() 方法，不多说，先看看源码长什么样：
public static void loop() {
//获取该线程中的Looper 实例
final Looper me = myLooper();
if (me == null) {
throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
}
//获取该线程中与Looper 相关联的 MessageQueue 对象
final MessageQueue queue = me.mQueue;
Binder.clearCallingIdentity();
final long ident = Binder.clearCallingIdentity();
for (;;) {
// 从MessageQueue 中取出 Message ，如果没有信息将会阻塞到这里
Message msg = queue.next(); // might block
if (msg == null) {
return;
}
final Printer logging = me.mLogging;
final long traceTag = me.mTraceTag;
if (traceTag != 0) {
Trace.traceBegin(traceTag, msg.target.getTraceName(msg));
}
try {
// 调用 Handler 将 Message 交个 Handler 处理
msg.target.dispatchMessage(msg);
} finally {
if (traceTag != 0) {
Trace.traceEnd(traceTag);
}
}
final long newIdent = Binder.clearCallingIdentity();
msg.recycleUnchecked();
}
}
通过上面的这段代码，我们可以知道 loop() 方法是如何循环消息的，上面的带有些没有用的就删掉了，在看的时候也不需要每行都要读懂，只要把注释的部分看懂就行。
现在看一下 Message
Message 类主要是存储信息的类，通过 Message 中的一些变量就可以看出，下面我们来看一下 Message 中的一个变量。
注意：Message 类实现了 Parcelable 接口进行序列化处理，为 Bundle 中进行数据传输
- Handler target
我们可以主要到这个在Message 中定义了一个 Handler 变量，如果第一次看代码可能会有些不知为何，那我们在来回顾一下 Looper 中刚刚我们提高过的一段代码：
public static void loop() {
........
for (;;) {
// 从MessageQueue 中取出 Message ，如果没有信息将会阻塞到这里
Message msg = queue.next(); // might block
// 调用 Handler 将 Message 交个 Handler 处理
msg.target.dispatchMessage(msg);
}
........
}
上面代码是 loop() 方法，无关代码已经删掉，通过这两行代码可以知道，在循环信息的时候，通过 MessageQuery 中取出 Message 消息，然后获取Message 中与该线程绑定的 Handler，再通过取出的该线程中的Handler 消息。
然后我们看一下 Handler
了解Handler 首先一定要看一下Handler 的构造方法，Handler 的构造方法有很多，在这里，我们只看这个 Handler(Callback callback, boolean 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;
}
在这些代码中让我关注的代码只有两行，mLooper = Looper.myLooper();这行代码很简单，获取该线程的Looper 实例。再看看 mQueue = mLooper.mQueue; 看到这行代码就更清楚了吧，获取该线程中 Looper 中的 MessageQuery 实例。
然在看一下 sendMessageAtTime(Message msg, long uptimeMillis) 和 enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) 两个方法：
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;
if (mAsynchronous) {
msg.setAsynchronous(true);
}
return queue.enqueueMessage(msg, uptimeMillis);
}
看到上面这两个方法代码也不多，从代码中可以看到，MessageQueue queue = mQueue;和queue.enqueueMessage(msg, uptimeMillis); 是向 MessageQueue 中添加 Message 消息。下面要重点说一下 msg.target = this; 这行代码，这行代码和前面介绍 Message 中变量相关联，这行代码是让 Message 持有这个Handler 实例，在Looper 循环消息时可以获取到该实例调用 Handler 中的 dispatchMessage 方法（下面会介绍 dispatchMessage），从而调用 handleMessage。
那么现在我们就来看一下 Handler 中的 dispatchMessage(Message msg) 方法：
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}
不用解释了吧， handleMessage(msg);
最后我们看一下 MessageQueue
在这个类中我们只看一个方法 enqueueMessage(Message msg, long when) 方法：
boolean enqueueMessage(Message msg, long when) {
if (msg.target == null) {
throw new IllegalArgumentException("Message must have a target.");
}
if (msg.isInUse()) {
throw new IllegalStateException(msg + " This message is already in use.");
}
synchronized (this) {
if (mQuitting) {
IllegalStateException e = new IllegalStateException(
msg.target + " sending message to a Handler on a dead thread");
Log.w(TAG, e.getMessage(), e);
msg.recycle();
return false;
}
msg.markInUse();
msg.when = when;
Message p = mMessages;
boolean needWake;
if (p == null || when == 0 || when < p.when) {
// New head, wake up the event queue if blocked.
msg.next = p;
mMessages = msg;
needWake = mBlocked;
} else {
// Inserted within the middle of the queue. Usually we don't have to wake
// up the event queue unless there is a barrier at the head of the queue
// and the message is the earliest asynchronous message in the queue.
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;
}
}
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;
}
这个方法代码很多，我么删一些没用的简化一下：
boolean enqueueMessage(Message msg, long when) {
synchronized (this) {
if (mQuitting) {
msg.recycle();
return false;
}
msg.markInUse();
msg.when = when;
Message p = mMessages;
boolean needWake;
if (p == null || when == 0 || when < p.when) {
msg.next = p;
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;
}
}
msg.next = p; // invariant: p == prev.next
prev.next = msg;
}
if (needWake) {
nativeWake(mPtr);
}
}
return true;
}
这个方法主要是将 Message 存入到 MessageQueue 中，供Looper 循环使用。
说了这么多，就会有人想问，既然 Looper 是 Handler 的核心，那么MainLooper 在什么时候被创建，下面我们在看一下 ActivityThread 类，一个 Android 程序的入口就在 ActivityThread 类中，所以，我们要看一下该类中 main 方法中的实现：
public static void main(String[] args) {
......
Looper.prepareMainLooper();
Looper.loop();
......
}
}
可以看到在main 函数中的两行代码创建了 Looper 实例和启动 Looepr 中的loop() 循环。
总结
在程序启动时，ActivityThread 类中启动应用，创建UI Thread 的 Looper， 在创建 UI Thread Looper 后又创建基于该线程的 MessageQuery 与该线程的Looper 进行关联，所以在activity 中创建的 Handler 是基于 UI Thread 的，所以 Looper 和 MessageQuery 早就已经创建好了。
