Handler的主要用途
- 在不同线程之间进行通信。
- 发送一个延迟消息，等到时间后再进行处理。
1.在不同线程之间进行通信。
使用场景：调用支付宝进行支付。因为Android规定了网络请求必须在子线程进行，所以我们在子线程处理了结果之后需要把结果发送到主线程来进行UI更新或执行其他操作。
private void initHandler() {
if (mHandler == null) {
mHandler = new Handler(new Handler.Callback() {
@Override
public boolean handleMessage(Message msg) {
if (msg.what==OrderInfoUtil2_0.SDK_PAY_FLAG) {
//成功调用支付接口，获取支付结果
PayResult payResult = new PayResult((Map<String, String>) msg.obj);
String resultStatus = payResult.getResultStatus();
if (TextUtils.equals(resultStatus, "9000")) {
// 判断resultStatus 为9000则代表支付成功
} else if (TextUtils.equals(resultStatus, "6001")) {
//支付取消
} else if (TextUtils.equals(resultStatus, "6002")) {
//网络异常
} else if (TextUtils.equals(resultStatus, "4000")) {
//系统异常
} else {
//支付失败
}
}
return true;
}
});
}
}
private void startAlipay(final String orderInfo) {
Runnable payRunnable = new Runnable() {
@Override
public void run() {
PayTask alipay = new PayTask(PayActivity.this);
//调用支付接口
Map<String, String> result = alipay.payV2(orderInfo, true);
//把支付结果发送到主线程的Handler进行处理
Message msg = Message.obtain();
msg.what = OrderInfoUtil2_0.SDK_PAY_FLAG;
msg.obj = result;
mHandler.sendMessage(msg);
}
};
mPayThread = new Thread(payRunnable);
mPayThread.start();
}
由此可见，只需要调用Handler的sendMessage方法就可以把消息从子线程发送到创建Handler所在的线程（代码里是主线程），从而实现了线程间的通信。具体的通信过程以后讲Looper和MessageQ的时候会说。
2.发送一个延迟消息，等到时间后再进行处理。
使用场景：执行定时任务。如果需要每间隔一定的时间去执行一个任务，相信很多人首先想到的都是使用Timer来实现，不过Timer是在子线程进行调度，所以又要处理线程间的通信问题。如果需要执行的任务不是一个耗时操作，使用Handler来实现最简单不过了。
private void initHandler() {
mHandler = new Handler();
mHandler.post(new Runnable() {
@Override
public void run() {
updateOrderInfo();
mHandler.postDelayed(this, 1000 * 60);
}
});
}
在上面的代码中首先马上发送了一个消息（Runnable最后会被包装成Message，对该Message的处理就是运行run（）方法），然后在消息执行体里面用Handler把该消息再次发送，但是是延迟60s后执行的。这样每次执行run（）方法的时候都会把该消息再次发送，从而达到了定时的效果。
Handler的构造方法
- Handler()
- Handler(Callback callback)
- Handler(Looper looper)
- Handler(Looper looper, Callback callback)
- Handler(boolean async)
- Handler(Callback callback, boolean async)
- Handler(Looper looper, Callback callback, boolean async)
虽然构造方法有7个之多，但是主要的参数就三个：Looper，Callback，async，其中包含async的构造函数都是加上了@hide注解的，也就意味着我们无法调用（反射可以，不过以后Google会禁止调用这类api）。下面对这几个参数进行解析：
Looper
Looper的作用就是不断的把Handler发送的消息取出来，并且交给Handler进行处理。每个线程都只能拥有一个Looper，Handler和它所在线程的Looper所绑定。所以当Handler在子线程发送消息的时，最终还是在Handler所在线程进行处理的，从而达到了异步通信的效果。
如果Handler构造函数没有传递Looper参数，则会自动获取当前线程所拥有的Looper，因为在主线程启动的时候系统就已经对主线程的Looper进行初始化了，所以如果我们要使用的Handler是在主线程上的可以不传递Looper参数。如果Handler是在子线程初始化的，则先要调用Looper.prepare()对子线程的Looper进行初始化，并且在Handler初始完之后调用Looper.loop()来开始取出Handler所发送的消息,使用方法如下：
class LooperThread extends Thread {
public Handler mHandler;
public void run() {
Looper.prepare();
mHandler = new Handler() {
public void handleMessage(Message msg) {
//处理接受到的消息
}
};
Looper.loop();
}
}
Callback
这是一个接口，里面只有一个方法handleMessage（），从方法名字可以看出，这个接口要做的事只有一件，就是处理消息。从Handler处理消息的顺序来看，这个Callback为第二优先级，具体的下面讲处理消息的时候会说明。
public interface Callback {
/**
* @param msg A {@link android.os.Message Message} object
* @return True if no further handling is desired
*/
public boolean handleMessage(Message msg);
}
async
这个变量代表着Handler发送的消息是否是异步的。在MessageQueue中有一个postSyncBarrier（）方法可以插入一个没有Handler的消息从而作为一个同步屏障（相当于一个标记作用），在取消息的时候如果发现了这个同步屏障，那在这之后的消息只有当是异步消息才会被处理，如果是同步消息则不会被处理。因为消息是按照他们要被处理的时间来排序的，所以如果是异步消息并且有同步屏障的情况下，这个消息是可能先于它前面的消息被处理的，这可能也是取名为异步的原因。
Handler的主要方法
- obtainMessage系列
- obtainMessage()
- obtainMessage(int what)
- obtainMessage(int what, Object obj)
- obtainMessage(int what, int arg1, int arg2)
- obtainMessage(int what, int arg1, int arg2, Object obj)
- post系列
- post(Runnable r)
- postAtTime(Runnable r, long uptimeMillis)
- postAtTime(Runnable r, Object token, long uptimeMillis)
- postDelayed(Runnable r, long delayMillis)
- postAtFrontOfQueue(Runnable r)
- send系列
- sendMessage(Message msg)
- sendEmptyMessage(int what)
- sendEmptyMessageDelayed(int what, long delayMillis)
- sendEmptyMessageAtTime(int what, long uptimeMillis)
- sendMessageDelayed(Message msg, long delayMillis)
- sendMessageAtTime(Message msg, long uptimeMillis)
- sendMessageAtFrontOfQueue(Message msg)
- hasMessages系列
- hasMessages(int what)
- hasMessagesOrCallbacks()
- hasMessages(int what, Object object)
- hasCallbacks(Runnable r)
- remove系列
- removeCallbacks(Runnable r)
- removeCallbacks(Runnable r, Object token)
- removeMessages(int what)
- removeMessages(int what, Object object)
- removeCallbacksAndMessages(Object token)
虽然方法看起来很多，但是相同系列的最后执行的目的基本是一样的，之所以提供那么多方法只是为了方便我们开发。如果对Message不了解的可以查看Android消息机制之Message源码解析
obtainMessage系列
这一系列都是重载方法，方法的参数都是为了构建一个Message，之所以提供这些方法是因为Message如果被回收了会被放在回收池了，如果回收池里有空闲的Message则对他的属性重新赋值后返回，这样就避免了频繁的创建对象。因此在开发的过程中建议使用这系列的方法去获取Message，而不是每次都new一个出来。
post系列和send系列
之所以把这两个系列放在一起讲，是因为他们最终都会调用到enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis)这个方法。
其中的MessageQueue为Handler的一个变量，在构造函数中赋值，主要负责消息的插入和移除操作。
Message自然就是要发送的消息对象了，无论是post系列还是send系列，其实就是把方法参数赋值进Message里面，然后让MessageQueue把这个Message插入消息队列中。
public final boolean sendEmptyMessageDelayed(int what, long delayMillis) {
Message msg = Message.obtain();
msg.what = what;
return sendMessageDelayed(msg, delayMillis);
}
最后的uptimeMillis表示这个消息应该在什么时候进行处理。因为消息都是发送到MessageQueue里面的Message变量里面，而Message是一个单链表实现的队列，插入的时候按照消息的uptimeMillis来选择合适的位置插入，越小的在越前面，这样在取消息的时候就会先被取出来（前提是到了该被处理的时间）。其中uptimeMillis对应的是系统启动后经过的毫秒数，可以通过SystemClock.uptimeMillis()获取当前所经过的毫秒数。
sendMessage/postAtTime(long uptimeMillis)就是指定一个具体的时间，等到了那个时间Handler就会收到这条消息。
sendMessage/postDelayed(long delayMillis)则是在当前时间过后的delayMillis毫秒后，Handler才会收到这条消息。它内部其实调用的是sendMessage/postAtTime(msg, SystemClock.uptimeMillis() + delayMillis)，因此可以通过发送该消息来执行延时任务。
sendMessage/postAtFrontOfQueue()则表示在Message队列的对头插入该条消息，意味着最先被处理。
hasMessages系列
顾名思义，就是判断在消息队列中是否存在这条消息。消息队列会对每个Message进行遍历，如果找到就返回true，没有就返回false。
remove系列
如果你发送了一条消息，但是突然又不想处理或者不应该再处理了，就可以把该消息从消息队列中删除。比如在Activity中发送了一个延迟消息，但是当Activity关闭的时候该消息还没开始处理，此时就应该在onDestroy()方法中把消息删除以防发生内存泄露。最简单的方法即是调用handler.removeCallbacksAndMessages(null);方法，它会把这个handler所有还没处理的消息删除。
dispatchMessage
讲了那么多终于到重头戏了，接下来就是最后一部分：处理消息。在Message从MessageQueue取出来之后会交给对应的Handler处理，还记得在Message简析里面有个target变量吗，记录了这个Message是由哪个Handler发送的，最终也交给它进行处理。交给它处理的方法就是调用target.dispatchMessage()方法，那我们来看下dispatchMessage()方法。
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}
第一步判断了msg.callback是否为null，这个callback对应着发送消息时使用的Runnable。如果不为null则执行handleCallback()方法，这个方法很简单，就是执行Runnable的run方法。
private static void handleCallback(Message message) {
message.callback.run();
}
第二步判断mCallback是否为null，这个mCallback对应的是Handler的构造函数里面Callback接口，里面也有一个handleMessage()方法，不过这个方法是带boolean返回值的，从代码可以看出来这个返回值如果为true则表示这个Message已经处理完成了，如果为false则代表还没处理完成，会继续传递给下一个处理方法。
第三步，如果之前的消息都没处理完成则会调用Handler自身的handleMessage()方法，从注释来看子类必须要实现该方法来接受Message。当然如果你使用的Callback的构造函数或者发送的都是Runnable消息则不用实现子类也可以。不过要提醒的是大多数人都是在Activity/Fragment中写一个内部类来继承Handler，因为内部类会隐式的持有外部类的引用，所以有可能导致内存泄漏。正确的写法是使用静态内部类和弱引用来持有外部类，或者使用Callback的构造函数更加方便。
/**
* Subclasses must implement this to receive messages.
*/
public void handleMessage(Message msg) {
}
所以可以看出来Runnable的消息执行优先级最高，第二为Handler构造函数里面的Callback接口，如果都没处理，或者callback的handleMessage返回了false，才轮到Handler自身的handleMessage方法对消息进行处理。
总结
Handler主要用于线程间通信和执行延迟任务，并且自身的主要职责就是发送消息和处理消息，至于消息的同步以及发送的消息该什么时候处理这些问题都不用它关心。但我们在使用的过程中需要注意内存泄漏问题，如果代码有warning提示有内存泄漏风险，那就该好好检查你的代码了。
如果看了还有什么不懂的，欢迎留言讨论。
