Handler是Android里面线程间通信的手段，它可以向自身持有的looper所在的线程发送消息进行通信。
先看看典型的带looper的线程的创建方法。
* class LooperThread extends Thread {
* public Handler mHandler;
*
* public void run() {
* Looper.prepare();
*
* mHandler = new Handler() {
* public void handleMessage(Message msg) {
* // process incoming messages here
* }
* };
*
* Looper.loop();
* }
* }
看看looper的注释
Class used to run a message loop for a thread. Threads by default do not have a message loop associated with them; to create one, call {@link #prepare} in the thread that is to run the loop, and then {@link #loop} to have it process messages until the loop is stopped.
上面注释的大意是，Looper类用来给一个线程运行消息循环。线程默认情况下是没有消息循环的。使用Looper.prepare方法和Looper.loop来运行循环并且让它处理消息。
可以看到上面的代码和注释的说明是一致的，在thread的run方法中，先调用Looper.prepare方法来初始化looper，然后调用Looper.loop来运行循环，并且初始化了handler
看看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));
}
...
public static @Nullable Looper myLooper() {
return sThreadLocal.get();
}
prepare方法new出了一个looper对象并把它放入了一个ThreadLocal变量，这样每一个带looper的线程将维护自己的一个looper对象。
private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}
looper构建的时候初始化了mQueue变量，它是一个MessageQueue对象。
再来看看Looper.loop()方法是如何运行循环的
public static void loop() {
...
for (;;) {
Message msg = queue.next(); // might block
...
...
msg.target.dispatchMessage(msg);
...
}
}
loop()方法中，通过一个死循环不断地通过调用MessageQueue的next方法获取message，在注释中可以看到，next方法可以被阻塞，如果没有获取到message就一直阻塞在这里直到获取到为止。然后调用msg.target的dispatchMessage方法，这里的msg.target其实就是handler，dispatchMessage方法就是我们创建handler的时候重写的dispatchMessage方法。
MessageQueue是一个典型的生产者/消费者队列，线程通过looper的loop方法不断地消费MessageQueue中的message，而生产者则是handler。
下面我们看看生产者handler是如何向MessageQueue发送message的。
先看看handler的创建过程，我们都知道不带参数的handler创建的时候必须在looper线程内创建，然后才能在其它线程中使用该handler向该线程发送消息，为啥要在线程内创建呢?
public Handler(Callback callback, boolean async) {
...
mLooper = Looper.myLooper();
if (mLooper == null) {
throw new RuntimeException(
"Can't create handler inside thread " + Thread.currentThread()
+ " that has not called Looper.prepare()");
}
mQueue = mLooper.mQueue;
mCallback = callback;
mAsynchronous = async;
}
不带参数的handler构造器最终调用了上面这个构造器。可以看到里面调用了
mLooper = Looper.myLooper();
这里的myLooper方法获取的就是前面说的存储在TheadLocal变量里面的当前线程的looper，然后又调用了
mQueue = mLooper.mQueue;
这里的mQueue就是上面说的MessageQueue。
所以就很明显啦，handler在哪个线程进行初始化，就会持有哪个线程的looper以及该线程looper内的MessageQueue，进而就会把消息发送到该线程的looper内的messageQueue。
事实上，Handler类是提供了带Looper参数的构造器的，使用这种构造器就不需要在Thread的run方法内部来初始化Handler了。
再来看handler发送message的过程，Handler的众多sendMessage和post方法最终都会调用这个方法
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);
}
可以看到把msg.target设置为了this，这里的this就是handler对象自己。
然后调用了MessageQueue的enqueueMessage方法，跟进去看看。
boolean enqueueMessage(Message msg, long when) {
...
synchronized (this) {
...
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;
}
MessageQueue里面维护了一个mMessages域，它是一个Message，可以看到Message是一个链表结构，enqueueMessage做的主要事情之一就是把message插入到mMessages中的合适位置。
这样，通过enqueueMessage方法，message就被handler放到MessageQueue中了。
综上，Handler的机制可以总结如下：
- Thread的run方法中，创建了一个ThreadLocal类型的域Looper。
- Looper又创建并持有一个MessageQueue。
- 然后Handler被创建并持有Looper和MessageQueue的引用。
- MessageQueue是一个生产者/消费者队列，Looper通过loop()方法中的死循环不断地向队列获取Message，获取到则调用Message所持有的Handler对象的dispatchMessage方法；如果获取不到则阻塞在那里。
- 被创建出来的Handler对象可以被其它的线程所持有并且生产出Message发送到队列中。