网上看了一堆各种Handler解析、详解的，但是感觉流程没有说透。我结合自己的理解和源码来综合性说说吧！
Handler源码定义的两大作用：
1.线程间通信
2.定时任务
一、Handler的初始化
我从定义构造方法开始讲起吧！
Handler的构造方法主要有两种，然后通过这两种形成各种使用灵活的构造方法！
第一种：
public Handler(Callback callback, boolean async) {//hide方法，默认无法构造
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;
}
相关的构造方法有：
public Handler() {
this(null, false);
}
public Handler(Callback callback) {
this(callback, false);
}
public Handler(boolean async) {//hide方法，默认无法构造
this(null, async);
}
第二种：
public Handler(Looper looper, Callback callback, boolean async) {//hide方法
mLooper = looper;
mQueue = looper.mQueue;
mCallback = callback;
mAsynchronous = async;
}
对应的各种构造方法是：
public Handler(Looper looper) {
this(looper, null, false);
}
public Handler(Looper looper, Callback callback) {
this(looper, callback, false);
}
两种方法的核心区别就是Looper的初始化，但是两种构造方法默认外部是无法调用的，Handler类隐藏了所有关于mAsynchronous的初始化设置！
先来说说第一种Handler的构建：
一来就是if判断，还是一个私有静态常量，一看就是用不上的，那么作用呢？
private static final boolean FIND_POTENTIAL_LEAKS = false;
官方解释是：将此标志设置为true以检测扩展的Handler类，如果不是静态的匿名，本地或成员类， 这类可能会产生泄漏。
也就是我们常见构造时的警告说明！至于消除警告方法一般是设置成静态或弱引用。继续看下面的代码
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;
首先是默认Looper的构造初始化，关于这些变量，我们先看看声明：
final MessageQueue mQueue;
final Looper mLooper;
final Callback mCallback;
final boolean mAsynchronous;
全都用final修饰，也就是说每一个Handler只能绑定一个Looper、一个MessageQueue、一个Callback。至于我们用来发送和接收的Message则没有任何限制！至于mAsynchronous一般构造方法获取到的，都是默认的false，主要是针对Message的排队处理！这里还有一点就是除了Callback外，其他变量都不能为空，否则消息处理时会抛异常，因为Callback接口内部方法未实现时会调用本地的handlerMessage方法，两者不同在于Callback的回调方法有boolean类型的返回值！
第二种构建方法就简单了，直接把需要初始化的局部变量赋值就行了，这里没什么可说的。
二、消息发送
Handler的消息发送主要有两种，一种是post，另一种是send。
先来看post处理方法。post主要是自己开启一个Runnable线程处理事件，并能指定事件的处理时间（延时多少时间处理）。重载方法如下：
public final boolean post(Runnable r)
{
return sendMessageDelayed(getPostMessage(r), 0);
}
public final boolean postAtTime(Runnable r, long uptimeMillis)
{
return sendMessageAtTime(getPostMessage(r), uptimeMillis);
}
public final boolean postAtTime(Runnable r, Object token, long uptimeMillis)
{
return sendMessageAtTime(getPostMessage(r, token), uptimeMillis);
}
public final boolean postAtTime(Runnable r, Object token, long uptimeMillis)
{
return sendMessageAtTime(getPostMessage(r, token), uptimeMillis);
}
public final boolean postDelayed(Runnable r, long delayMillis)
{
return sendMessageDelayed(getPostMessage(r), delayMillis);
}
public final boolean postAtFrontOfQueue(Runnable r)//特殊方法
{
return sendMessageAtFrontOfQueue(getPostMessage(r));
}
从上面可以看出，post方法最终调用的还是send方法将消息添加到消息队列，而且还都是final方法，不可重写，也提高了执行效率。现在来讲解第一个方法，其他类似。post方法默认调用了sendMessageDelayed(getPostMessage(r), 0); 。先来看看线程处理方法getPostMessage(r)：
private static Message getPostMessage(Runnable r) {
Message m = Message.obtain();
m.callback = r;
return m;
}
私有的静态方法，是为了将处理事件添加到Message消息线程中，并返回了Message。
在看sendMessageDelayed方法
public final boolean sendMessageDelayed(Message msg, long delayMillis)
{
if (delayMillis < 0) {
delayMillis = 0;
}
return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
}
直接就是调用send方法了。也就是说post方法最后还是要调用send方法来将消息添加到消息队列中，下面我们来看直接来看send方法。
public final boolean sendMessage(Message msg)
{
return sendMessageDelayed(msg, 0);
}
public final boolean sendEmptyMessage(int what)
{
return sendEmptyMessageDelayed(what, 0);
}
public final boolean sendEmptyMessageDelayed(int what, long delayMillis) {
Message msg = Message.obtain();
msg.what = what;
return sendMessageDelayed(msg, delayMillis);
}
public final boolean sendEmptyMessageAtTime(int what, long uptimeMillis) {
Message msg = Message.obtain();
msg.what = what;
return sendMessageAtTime(msg, uptimeMillis);
}
public final boolean sendMessageDelayed(Message msg, long delayMillis)
{
if (delayMillis < 0) {
delayMillis = 0;
}
return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
}
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);
}
public final boolean sendMessageAtFrontOfQueue(Message msg) {//特殊方法
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, 0);
}
还是从最简单的sendMessage方法说起，直接调用sendMessageDelayed方法，继续看，延时做了合法性判断后调用了sendMessageAtTime方法，也就是指定任务的执行发生时间。继续看里面的代码，先是获取的此Handler的消息队列MessageQueue，并做了null判断，这里先不探讨出现null的情况，继续往下看，然后调用了enqueueMessage方法：
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
msg.target = this;
if (mAsynchronous) {
msg.setAsynchronous(true);
}
return queue.enqueueMessage(msg, uptimeMillis);
}
这个私有方法就将消息添加到了消息队列中，消息发送也就完成了。
在post和send方法中，有一种比较特殊的消息发送机制，就是消息插队（备注的特殊方法），也就是postAtFrontOfQueue和sendMessageAtFrontOfQueue方法，因为postAtFrontOfQueue是通过sendMessageAtFrontOfQueue方法实现的，但最终还是一样的，只不过这种方法会出排序问题或其他情况等，一般很少使用！
从上面可以看出，无论是post还是send方方法，都是将Message添加到MessageQueue中，Handler还提供了获取Message的几种构造方法：
public final Message obtainMessage()
{
return Message.obtain(this);
}
public final Message obtainMessage(int what)
{
return Message.obtain(this, what);
}
public final Message obtainMessage(int what, Object obj)
{
return Message.obtain(this, what, obj);
}
public final Message obtainMessage(int what, int arg1, int arg2)
{
return Message.obtain(this, what, arg1, arg2);
}
public final Message obtainMessage(int what, int arg1, int arg2, Object obj)
{
return Message.obtain(this, what, arg1, arg2, obj);
}
基本都是Message的构造方法，但全部没有用new方法，而是通过obtain方法获取，而这也是Message类推荐的。
到这里Handler的消息发送和发送相关的方法就基本讲完了！Handler的主要方法之一也就讲的差不多了！下一节继续Handler的消息移除和消息处理！
