Handler的由来
当程序第一次启动的时候，Android会同时启动一条主线程（Main Thread）来负责处理与UI相关的事件，我们叫做UI线程。
Android的UI操作并不是线程安全的（出于性能优化考虑），意味着如果多个线程并发操作UI线程，可能导致线程安全问题。
为了解决Android应用多线程问题——Android平台只允许U线程修改Activity里的UI组件，就会导致新启动的线程无法改变界面组件的属性值。
简单总结：当主线程队列处理一个消息超过5秒，android就会抛出一个ANR（无响应）的异常，所以，我们需要把一些要处理时间比较长的消息，放在一个单独线程里面进行处理，把处理以后的结果，返回给主线程运行，就需要用到Handler来进行线程组件的通信。
Handler的作用
- 让线程延时执行，主要用到两个方法：
方法1：final boolean postAtTime(Runnable r, long uptimeMillis)
方法2：final boolean postDelayed(Runnable r, long delayMillis)```
* 让任务在其他线程中执行并返回结果，分为两个步骤：
**1.在新启动的线程中发送消息**
使用Handler对象的```sendMessage()```方法或者```sendEmptyMessage()```方法发送消息。
**2.在主线程中获取处理消息**
重写Handler类中处理消息的方法（void handleMessage(Message msg)）,当新启动的线程发送消息时，消息发送到与之关联的MessageQueue。而Handler不断地从MessageQueue中获取并处理消息。
#####Handler更新UI线程一般使用
(1)：首先要进行Handler声明，复用handleMessage方法（放在主线程中）
private Handler handler = new Handler() {
@Override
public void handleMessage(Message msg) {
// TODO 接收消息并且去更新UI线程上的控件内容
if (msg.what == UPDATE) {
// 更新界面上的textview
tv.setText(String.valueOf(msg.obj));
}
super.handleMessage(msg);
}
};```
(2)：子线程发送Message给UI线程表示自己任务已经执行完成，主线程可以做相应的操作了。
new Thread() {
@Override
public void run() {
// TODO 子线程中通过handler发送消息给handler接收
//，由handler去更新TextView的值
try {
//do something
Message msg = new Message();
msg.what = UPDATE;
msg.obj = "更新后的值" ;
handler.sendMessage(msg);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}.start();```
#####Handler原理分析
* **Handler的构造函数**
1: public Handler()
2: public Handler(Callback callback)
3: public Handler(Looper looper)
4: public Handler(Looper looper, Callback callback) ```
第①个和第②个构造函数都没有传递Looper，这两个构造函数都将通过调用Looper.myLooper()获取当前线程绑定的Looper对象，然后将该Looper对象保存到名为mLooper的成员字段中。
下面来看①②个函数源码：
public Handler() {
this(null, false);
}
public Handler(Callback callback) {
this(callback, false);
}
//他们会调用Handler的内部构造方法
public Handler(Callback callback, boolean async) {
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());
}
}
//重点：Looper.myLooper()获取了当前线程保存的Looper实例
mLooper = Looper.myLooper();
if (mLooper == null) {
throw new RuntimeException(
"Can't create handler inside thread that has not
called Looper.prepare()");
}
//重点：获取MessageQueue（消息队列）
mQueue = mLooper.mQueue;
mCallback = callback;
mAsynchronous = async;
}```
**通过Looper.myLooper()获取了当前线程保存的Looper实例，又通过这个Looper实例获取了其中保存的MessageQueue（消息队列）。每个Handler对应一个Looper对象，产生一个MessageQueue**
第③个和第④个构造函数传递了Looper对象，这两个构造函数会将该Looper保存到名为mLooper的成员字段中。
下面来看③④个函数源码：
public Handler(Looper looper) {
this(looper, null, false);
}
public Handler(Looper looper, Callback callback) {
this(looper, callback, false);
}
//他们会调用Handler的内部构造方法
public Handler(Looper looper, Callback callback, boolean async) {
mLooper = looper;
mQueue = looper.mQueue;
mCallback = callback;
mAsynchronous = async;
}
第②个和第④个构造函数还传递了Callback对象，Callback是Handler中的内部接口，需要实现其内部的handleMessage方法，Callback代码如下:
public interface Callback {
public boolean More ...handleMessage(Message msg);
}```
Handler.Callback是用来处理Message的一种手段，如果没有传递该参数，那么就应该重写Handler的handleMessage方法，也就是说为了使得Handler能够处理Message，我们有两种办法：
方法1：向Hanlder的构造函数传入一个Handler.Callback对象，并实现Handler.Callback的handleMessage方法
方法2：无需向Hanlder的构造函数传入Handler.Callback对象，但是需要重写Handler本身的handleMessage方法
也就是说无论哪种方式，我们都得通过某种方式实现handleMessage方法，这点与Java中对Thread的设计有异曲同工之处。
- Handle发送消息的几个方法源码
//发送消息
public final boolean sendMessage(Message msg){
return sendMessageDelayed(msg, 0);
}```
//发送空消息，并且带有时间延迟
public final boolean sendEmptyMessageDelayed(int what, long delayMillis) {
Message msg = Message.obtain();
msg.what = what;
return sendMessageDelayed(msg, delayMillis);
}```
//发送消息，并且带有时间延迟
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);
}```
我们可以看出他们最后都调用了sendMessageAtTime（），然后返回了enqueueMessage方法，下面看一下此方法源码：
private boolean enqueueMessage(MessageQueue queue
, Message msg, long uptimeMillis) {
//把当前的handler作为msg的target属性
msg.target = this;
if (mAsynchronous) {
msg.setAsynchronous(true);
}
return queue.enqueueMessage(msg, uptimeMillis);
}```
在该方法中有两件事需要注意：
**1. msg.target = this;**该代码将Message的target绑定为当前的Handler
**2. queue.enqueueMessage **
变量queue表示的是Handler所绑定的消息队列MessageQueue，通过queue.enqueueMessage(msg,uptimeMillis)我们将Message放入到消息队列中。
下面通过一张图，来看完整的方法调用顺序：
#####Looper原理分析
我们一般在主线程声明Handler，有时我们需要继承Thread类实现自己的线程功能，当我们在里面声明Handler的时候会报错。其原因是主线程中已经实现了两个重要的Looper方法，下面看一看ActivityThread.java中main方法的源码：
public static void main(String[] args) {
//......省略
Looper.prepareMainLooper();
ActivityThread thread = new ActivityThread();
thread.attach(false);
if (sMainThreadHandler == null) {
sMainThreadHandler = thread.getHandler();
}
AsyncTask.init();
if (false) {
Looper.myLooper().setMessageLogging(new
LogPrinter(Log.DEBUG, "ActivityThread"));
}
Looper.loop();
throw new RuntimeException("Main thread loop
unexpectedly exited");
}```
- 首先看prepare()方法
public static void prepare() {
prepare(true);
}
private static void prepare(boolean quitAllowed) {
//证明了一个线程中只有一个Looper实例
if (sThreadLocal.get() != null) {
throw new RuntimeException("Only one Looper may be
created per thread");
}
sThreadLocal.set(new Looper(quitAllowed));
}```
该方法会调用Looper构造函数同时实例化出MessageQueue和当前thread.
private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}
public static MessageQueue myQueue() {
return myLooper().mQueue;
}```
prepare()方法中通过ThreadLocal对象实现Looper实例与线程的绑定。（不清楚的可以查看 ThreadLocal的使用规则和源码分析）
- 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 block
if (msg == null) {
return;
}
Printer logging = me.mLogging;
if (logging != null) {
logging.println(">>>>> Dispatching to " + msg.target + " "
+ msg.callback + ": " + msg.what);
}
//重点****
msg.target.dispatchMessage(msg);
if (logging != null) {
logging.println("<<<<< Finished to " + msg.target + " "
+ msg.callback);
}
// identity of the thread wasn't corrupted.
final long newIdent = Binder.clearCallingIdentity();
if (ident != newIdent) {
Log.wtf(TAG, "Thread identity changed from 0x"
+ Long.toHexString(ident) + " to 0x"
+ Long.toHexString(newIdent)
+ " while dispatching to "
+ msg.target.getClass().getName() + " "
+ msg.callback + " what=" + msg.what);
}
msg.recycleUnchecked();
}
}```
首先looper对象不能为空，就是说loop()方法调用必须在prepare()方法的后面。
Looper一直在不断的从消息队列中通过MessageQueue的next方法获取Message，然后通过代码```msg.target.dispatchMessage(msg)```让该msg所绑定的Handler执行dispatchMessage()方法以实现对Message的处理。
Handler的dispatchMessage的源码如下：
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}```
我们可以看到Handler提供了三种途径处理Message，erqie处理有前后优先级之分：首先尝试让postXXX()中传递的Runable执行，其次尝试让Handler构造函数中传入的Callback的handleMessage()方法处理，最后才是让Handler自身的handleMessage()方法处理Message。
如何在子线程中使用Handler
Handler本质是从当前的线程中获取到Looper来监听和操作MessageQueue，当其他线程执行完成后回调当前线程。
子线程需要先prepare()才能获取到Looper对象，是因为子线程只是一个普通的线程，其ThreadLoacl中没有设置过Looper，所以会抛出异常，而在Looper的prepare()方法中sThreadLocal.set(new Looper())是设置了Looper的。
- 实例代码：定义一个类实现Runnable接口或继承Thread类（一般不继承）。
class Rub implements Runnable {
public Handler myHandler;
// 实现Runnable接口的线程体
@Override
public void run() {
/*1、调用Looper的prepare()方法为当前线程创建Looper对象并，
创建Looper对象时，它的构造器会自动的创建相对应的MessageQueue*/
Looper.prepare();
/*2、创建Handler子类的实例，重写HandleMessage()方法
，该方法处理除当前线程以外线程的消息*/
myHandler = new Handler() {
@Override
public void handleMessage(Message msg) {
String ms = "";
if (msg.what == 0x777) {
}
}
};
//3、调用Looper的loop()方法来启动Looper让消息队列转动起来
Looper.loop();
}
}```
**注意分成三步：**
1：调用Looper的prepare()方法为当前线程创建Looper对象，创建Looper对象时，它的构造器会创建与之配套的MessageQueue。
2：有了Looper之后，创建Handler子类实例，重写HanderMessage()方法，该方法负责处理来自于其他线程的消息。
3：调用Looper的looper()方法启动Looper。然后使用这个handler实例在任何其他线程中发送消息，最终处理消息的代码都会在你创建的Handler实例的线程中运行。
#####总结
* **Handler**
发送消息，它能把消息发送给Looper管理的MessageQueue，Looper分发给它消息。
* **Message**
Handler接收和处理的消息对象。
* **Looper**
每个线程只有一个Looper，它负责管理对应的MessageQueue，会不断地从MessageQueue中取出消息，并将消息Messsge分发给对应的Handler进行处理。
主线程中，系统已经初始化了一个Looper对象，因此可以直接创建Handler即可，就可以通过Handler来发送消息、处理消息。程序自己启动的子线程，程序必须自己创建一个Looper对象，bignqie启动它，调用Looper.prepare()方法。
* **prapare()方法**
保证每个线程最多只有一个Looper对象。
* **looper()方法**
启动Looper，使用一个死循环不断取出MessageQueue中的消息，并将取出的消息分发给对应的Handler进行处理。
* **MessageQueue**
由Looper负责管理，它采用先进先出的方式来管理Message。
* **Handler的构造方法**
会首先得到当前线程中保存的Looper实例，进而与Looper实例中的MessageQueue相关联。
* **Handler的sendMessage方法**
会给msg的target赋值为handler自身，然后加入MessageQueue中。
参考链接：
[线程通信基础流程分析（Handler、Looper、Message、MessageQueue）](https://github.com/GeniusVJR/LearningNotes/blob/master/Part1/Android/%E7%BA%BF%E7%A8%8B%E9%80%9A%E4%BF%A1%E5%9F%BA%E7%A1%80%E6%B5%81%E7%A8%8B%E5%88%86%E6%9E%90.md)
**结束语：越努力，越幸运！加油 ---王令
QQ：2585085940
邮箱：wang91ling@163.com
欢迎大家光临寒舍。**