在刚学习Android网络请求时，肯定会接触到UI阻塞，然后认识了Handler,Handler是我们最常用的解决方案之一。
简单点说Handler其实就是解决多线程通信的一个东西，那它是怎么具体工作的呢？Looper和MessageQueue又是什么，和Handler又和什么关联呢？让我们来慢慢分析。

首先我们先来看看主线程是怎么工作的，我们知道在Android启动时，会默认有一个主线程（UI线程），在主线程中会关联一个MessageQueue,所有操作都会封装成一个消息来由主线程处理。为了保证主线程不会主动退出，主线程会把所有获得消息的操作放在一个死循环中，这样主线程就会一直处理消息，整个系统通信也就跑起来了，如下图：

Handler.png

主线程的Looper是怎么自动创建的？

主线程是在ActivityThread.main方法中创建的，ActivityThread.main是应用程序的入口。
部分源代码：

…
Process.setArgV0("<pre-initialized>");

//创建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.