在刚学习Android网络请求时，肯定会接触到UI阻塞，然后认识了Handler,Handler是我们最常用的解决方案之一。
简单点说Handler其实就是解决多线程通信的一个东西，那它是怎么具体工作的呢？Looper和MessageQueue又是什么，和Handler又和什么关联呢？让我们来慢慢分析。
首先我们先来看看主线程是怎么工作的，我们知道在Android启动时，会默认有一个主线程（UI线程），在主线程中会关联一个MessageQueue,所有操作都会封装成一个消息来由主线程处理。为了保证主线程不会主动退出，主线程会把所有获得消息的操作放在一个死循环中，这样主线程就会一直处理消息，整个系统通信也就跑起来了，如下图：
主线程的Looper是怎么自动创建的？
主线程是在ActivityThread.main方法中创建的，ActivityThread.main是应用程序的入口。
部分源代码：
…
Process.setArgV0("");
//创建Looper对象
Looper.prepareMainLooper();
ActivityThread thread = new ActivityThread();
thread.attach(false);
if (sMainThreadHandler == null) {
sMainThreadHandler = thread.getHandler();
}
if (false) {
Looper.myLooper().setMessageLogging(new
LogPrinter(Log.DEBUG, "ActivityThread"));
}
// End of event ActivityThreadMain.
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
//执行消息循环，让MessageQueue动起来
Looper.loop();
throw new RuntimeException("Main thread loop unexpectedly exited");
…
执行完ActivityThread.main方法，应用程序就启动起来了，并且会一直从消息队形中存消息、取消息然后处理消息，这样整个系统就转起来了。
Handler、Looper、MessageQueue之间的对应关系？
由于主线程阻塞超过5秒会ANR，所以一些耗时任务都是交给子线程来处理的，子线程处理好后想要交给主线程更新UI,我们知道子线程是不可以更新UI的，一般我们最常用的手段就是Handler,Handler从子线程拿到的数据封装成消息Post到主线程，然后Handler再在HandleMessage方法中处理更新UI，但是Handle必须在主线程中创建！为什么Handle必须在主线中创建呢？因为一个Handler对应一个MessageQueue,而MessageQueue被封装在Looper中，所以说一个Handler对应一个Looper,而Looper又被ThreadLocal封装在Thread中，最终每个消息队列会关联一个线程。默认情况下，消息队列只有一个就是在主线程消息队列，即在ActivityThread.main方法中创建的，最后启用Looper.loop来执行循环。
Handler是如何关联MessageQueue和线程的呢？
我们来看看Handler部分源码：
public Handler()
{
…
mLooper = Looper.myLooper(); //获取Looper对象
if (mLooper == null) {
throw new RuntimeException(
"Can't create handler inside thread that has not called Looper.prepare()");
}
mQueue = mLooper.mQueue; //获取MessageQueue对象
mCallback = callback;
mAsynchronous = async;
…
}
在Handler的构造方法中，用Looper.myLooper获得Looper对象，又从Looper对象中获得MessageQueue对象，那么Looper.myLooper()又是怎么工作的呢？
Hoopler类部分源代码：
//为当前线程设置一个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));
}
//创建主线程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();
}
}
myLooper方法通过sThreadLocal.get()来获取的，prepare()方法中sThreadLocal设置了Looper对象，这样Looper就和Handler关联起来了，即Handler和线程也就关联起来了。
看到这里也就解释了为什么Handler只能在主线程中创建了，因为Handler要与主线程关联，这样才能在HandlerMessage方法中更新UI，此时，更新UI才是安全的。
Looper是如何执行消息循环的？
消息循环的建立是通过Looper.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.");
}
final MessageQueue queue = me.mQueue;
//死循环
for (;;) {
Message msg = queue.next(); //从队列中获取消息
if (msg == null) {
// No message indicates that the message queue is quitting.
return;
}
//把消息传给Handler
msg.target.dispatchMessage(msg);
//回收消息
msg.recycleUnchecked();
}
}
Loop()方法其实是一个死循环，不断地从中取出消息仍给Handler。
我们总结一下Looper,通过 Looper.prepare()获得对象，然后通过Looper.loop()不断循环，这两步是成对出现的。
消息处理的机制？
msg.target.dispatchMessage(msg);这句是loop()方法中处理的方法，那它是怎么工作的呢？target是一个Handler类型，target通过Handler投递到MessageQueue然后又分发到Handler处理，整个流程走一遍，下面再看看dispatchMessage()方法源码：
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}
从中可以看到dispatchMessage()方法只是一个分发方法 ，如果Runable类型的callback为空，则执行handlerMessage(),我们会将更新UI的代码写在这个方法中。当callback不为空时，会执行handCallback来处理，该方法会调用callback的run方法，其实这是Handler分发的两种类型，比如post(Runable callback)则callback不会为空，而sendMessage()一般不会设置callback，因此执行handMessage()这个分支，源码如下：
public final boolean post(Runnable r)
{
return sendMessageDelayed(getPostMessage(r), 0);
}
public final boolean sendMessageDelayed(Message msg, long delayMillis)
{
if (delayMillis < 0) {
delayMillis = 0;
}
return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
}
在上述程序中看到，post()方法中会把Runable包装成一个Message对象然后调用sendMessageDelayed()方法插入到MessageQueue。
总结
Handler通过Looper.myLooper()拿到Looper实例，又通过Looper实例拿到MessageQuenu实例，这样Handler就与线程建立联系了，Handler把子线程的消息Post到MessageQueue,消息在MessageQueue循环,Looper利用dispatchMessage分发消息，handlerMessage或者callback方法拿回消息进行更新UI.