首先明确， handler是为了解决单进程内的线程之间的通信问题的。我也需要理解Android系统中进程和线程的概念， APP启动后，会有三四个线程启动起来，其中，有一条mainUITread的线程，专门用来处理UI事件，以及显示组件的生命周期，多个Activity的线程都是同一个。此外还要知晓，单进程内的多线程是共享内存、信号量、运行指令。如下图：

除了私有栈区，不能相互共享， 代码的方法指令、数据都可以在进程内任意线程执行。这里大家先记住这点， 在后面的问题3的解释中会用到。
enqueueMessage中的消息的存入，是可以设置时间先后的；
我们本篇幅文章只讨论三个问题：
1. Handler 的消息发送过程；
2. Message 被消耗的过程；
3. 为何需要Handler这个类的原因；

基础知识

跟handler相关的类：
Handler：发送消息的快递员（属于某个快递公司的职员）
Message：承担消息的包裹（可以放置很多东西的箱子）
MessageQueue：消息中心（这里会按照消息带的时间长短，一个排列好消息的单链表）
Looper： 真正在消费消息的永动机（这个是在主线程的，上面三个都在另一个线程里）

问题1#：Handler 的消息产生和发送过程

我们在Activity中的应用场景：
创建Handler的对象，里面也重写了真正去使用msg的回调方法：
//创建 Handler对象，并关联主线程消息队列

mHandler = new Handler(Looper.getMainLooper()) {@Overridepublic void handleMessage(Message msg) {super.handleMessage(msg);···略···}}
};

发送消息：

Message msg = new Message();
msg.setData(bundle);
msg.what = 2;
mHandler.sendMessage(msg)

消息的产生， 可以在任何地方通过Message 去创建，它是一个比较简单的实体类， 包含1、what,when,target等。 这里面说一下：
2、what:就是携带的数据,Int类型；
3、when:这个一般不怎么用， 但是是可以使用，具体是输入时间长短后，当在msg发送到MessageQueue的队列里， 会根据when和当前时间来推送，需要去消费它的具体时间， 跟队列里的消息进行对比，然后排列插进去；
4、target: 这个一般我们没有赋值，是因为他在Messag的实例化对象的时候【obtain()方法】或者是在message的后续传递中底层会帮我们赋值， 这个在最后looper里消费的时候， 会使用，用它找到这个消息是用哪个handler来消费，调用他的handleMessage（）方法。 这里也就说明了， 一个looper是支持绑定多个hander对象的，同时也不会混乱。

我们现在看一下handler的实例化过程：

public Handler(Callback callback, boolean async) {//......mLooper = Looper.myLooper();  //返回与当前线程关联的Looper对象，在后面Looper会讲到if (mLooper == null) {throw new RuntimeException("Can't create handler inside thread " + Thread.currentThread()+ " that has not called Looper.prepare()");}mQueue = mLooper.mQueue;  //返回Looper对象的消息队列，在后面MessageQueue会讲到mCallback = callback;  //接口回调mAsynchronous = async; //是否异步}public interface Callback {public boolean handleMessage(Message msg); //这个函数大家都很熟悉了，暂不细说，总之都知道是用来回调消息的}

整个构造方法的过程中会确立以下几件事：

• 获取当前Handler实例所在线程的Looper对象：mLooper = Looper.myLooper()，这个looper获取的就是主线程那个loop
• 如果Looper不为空，则获取Looper的消息队列，赋值给Handler的成员变量mQueue：mQueue = mLooper.mQueue
• 可以设置Callback 来处理消息回调：mCallback = callback。

looper这里面为什么没有创建直接获取呢， 因为我们的Activity在每次创建的时候，
ActivityThread的1个静态的main（）；
而main（）内则会调用Looper.prepareMainLooper()为主线程生成1个Looper对象，同时也会生成其对应的MessageQueue对象。为进程中的管理进行初始化。
public static void main(String[] args) {
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, “ActivityThreadMain”);

    // Install selective syscall interceptionAndroidOs.install();// CloseGuard defaults to true and can be quite spammy.  We// disable it here, but selectively enable it later (via// StrictMode) on debug builds, but using DropBox, not logs.CloseGuard.setEnabled(false);Environment.initForCurrentUser();// Make sure TrustedCertificateStore looks in the right place for CA certificatesfinal File configDir = Environment.getUserConfigDirectory(UserHandle.myUserId());TrustedCertificateStore.setDefaultUserDirectory(configDir);// Call per-process mainline module initialization.initializeMainlineModules();Process.setArgV0("<pre-initialized>");Looper.prepareMainLooper();  // 在这里创建新的looper

ActivityThread thread = new ActivityThread();
thread.attach(false);

    if (sMainThreadHandler == null) {sMainThreadHandler = thread.getHandler();// 获取Handler}if (false) {Looper.myLooper().setMessageLogging(newLogPrinter(Log.DEBUG, "ActivityThread"));}// End of event ActivityThreadMain.Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);Looper.loop();// 开始调用loop()方法

好了，言归正传， handler创建完成调用

mHandler.sendMessage(msg)方法进行发送:

public boolean sendMessageAtTime(Message msg, long uptimeMillis) {
MessageQueue queue = mQueue; //获得当前的消息队列
if (queue == null) { //若是在创建Handler时没有指定Looper，就不会有对应的消息队列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;   //这个target就是前面我们说到过的if (mAsynchronous) {msg.setAsynchronous(true);}return queue.enqueueMessage(msg, uptimeMillis);
}

消息通过这个方法 queue.enqueueMessage（msg, uptimeMillis）进入到了queue队列里了。

boolean enqueueMessage(Message msg, long when) {if (msg.target == null) {  //判断msg的所属Handlerthrow new IllegalArgumentException("Message must have a target.");}//......synchronized (this) {  //因为是队列，有先后之分，所以用了同步机制//......msg.when = when;Message p = mMessages;  //对列中排在最后的那个Message //......if (p == null || when == 0 || when < p.when) {    //若队列为空，或者等待时间为0，或者比前面那位的等待时间要短，就插队msg.next = p;  //此处的next就是前面我们在Message提到的，指向队列的下一个结点mMessages = msg;//......} else { //......Message prev;for (;;) {     //此处for循环是为了取出一个空的或者when比当前Message长的一个消息，然后进行插入prev = p;p = p.next;if (p == null || when < p.when) {break;}//......}msg.next = p;       // 置换插入prev.next = msg;  // 置换插入}//......}return true;}

这个就消息新建产生，然后发送到了queue的消息队列里，对待looper去取然后分发消费了。

问题2#：Message的消费过程

这个我们要看一下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;Binder.clearCallingIdentity();final long ident = Binder.clearCallingIdentity();for (;;) {// 无限循环Message msg = queue.next(); // might blockif (msg == null) {// No message indicates that the message queue is quitting.return;}......final long start = (slowDispatchThresholdMs == 0) ? 0 : SystemClock.uptimeMillis();final long end;try {// 处理消息msg.target.dispatchMessage(msg);......}

前面有代码片里说到 ActivityThread.mian-> Looper.prepareMainLooper()->mLooper.loop():
我们只要看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;Binder.clearCallingIdentity();final long ident = Binder.clearCallingIdentity();for (;;) {// 无限循环Message msg = queue.next(); // might blockif (msg == null) {// No message indicates that the message queue is quitting.return;}......final long start = (slowDispatchThresholdMs == 0) ? 0 : SystemClock.uptimeMillis();final long end;try {// 处理消息msg.target.dispatchMessage(msg);......

这里面就看到，两件事情，根据target来判断是哪个handler，同时调用它的dispatchMessage来分发消息：

 public void dispatchMessage(Message msg) {if (msg.callback != null) {handleCallback(msg);} else {if (mCallback != null) {if (mCallback.handleMessage(msg)) {return;}}handleMessage(msg);}}

最终调用了 我们附带了的callback的handleMessage（）方法。

这里面还有一个疑惑， looper是怎么能够一直处理消息的。 大家看loop()方法中， 有一个for(;;)死循环，这个其实就是永远在轮询队列中的消息，for循环是可以被阻塞的， 在这里就是这个函数Message msg = queue.next(); 就是如果队列没有消息了，它就会阻塞， 类似thread.sleep(1000)的方法。 当有新消息， queue.next()就会正常，继续执行消息。

问题3#： 为什么需要handler

需要handler，是因为在Android的设计里，不允许除了UI主线程外的其他线程对UI进行操作，最终都会走到View.requestLayout()里面判断当前线程是否是主线。
所以我们就需要想办法，需要子线程执行的某个阶段，有需求更新UI,那我们就必须通知在主线程里面去执行刷新UI的代码，这个在很多地方都有这种设计， 设计一个轮转片的循环，线程内的通信，通过消息来通知。 比如JS这种单线程设计语言， 就有Emit的设计。
1.创建了一个Looper对象保存在ThreadLocal中。这个Looper同时持有一个MessageQueue对象。
2.创建Handler获取到Looper对象和MessageQueue对象。在调用sendMessage方法的时候在不同的线程（子线程）中把消息插入MessageQueue队列。

3.在主线程中（UI线程），调用Looper的loop()方法无限循环查询MessageQueue队列是否有消息保存了。有消息就取出来调用dispatchMessage()方法处理。这个方法最终调用了我们自己重写了消息处理方法handleMessage(msg);这样就完成消息从子线程到主线程的无声切换。

最后补充：我们经常使用Handler没有创建Looper调用Looper.pepare()和Looper.loop()是因为在ActivityThread中已经创建了主线程的Looper对象，保存在了ThreadLocal中，我们在创建Hander的时候就会从ThreadLocal中取出来这个Looper。