彻底掌握Handler，含源码分析
定义
Android 的一种消息传递机制，用于异步处理
背景
为了保证线程安全，Android 只允许主线程更新UI，如果工作线程想要更新UI必须让主线程执行，Handler的出现就是用于工作线程与主线程间的通信
概念
主线程（UI线程）：ActivityThread，APP启动时会自动启动一条主线程用于执行UI更新操作
工作线程：用于执行耗时任务（网络请求、计算），避免出现ANR
消息：Message，线程通信的数据单元
消息队列：MessageQueue，先进先出的数据结构（单链表），用于存放消息
处理器：Handler，一个Handler实例必须与一个Looper对象关联，当你创建一个新的Handler，它会和一个Looper进行绑定（不一定是当前线程的Looper，其他线程创建好的Looper也可以），它将向Looper关联的的消息队列发送消息，并在Looper的线程上执行它们
循环器：Looper，一个线程持有一个Looper，一个Looper持有一个MessageQueue，但是一个Looper可以与多个Handler绑定，这样多个Handler将消息传给同一个Looper的消息队列中，由Looper将消息取出分发给不同的Handler（与它绑定的Handler们），从而实现线程通信
使用方式
定义
class MyHandler extends Handler {//子类
@override
public void handleMessage(Message msg) {
//用于处理接收到的消息
}
}
private Handler myHandler = new Handler() {//匿名内部类
@override
public void handleMessage(Message msg) {
//用于处理接收到的消息
}
}；
发送
//1.sendMessage()
private Handler myHandler = new MyHandler();
Message msg = Message.botain();
msg.what= 0x22;
msg.msg = 1;
myHandler.sendMessage(msg);
//2.post()
//在主线程中创建Handler对象myHandler，在工作线程中使用该对象执行post()方法
myHandler.post(new Runnable(){
@override
public void run() {
//直接写你要干什么
}
})
这两种使用方式底层都是调用了同一个方法sendMessageDelayed，最终通过MQ中的enqueueMessage方法实现消息入队
工作原理
异步通信准备
在线程中创建处理器Handler、循环器Looper及消息队列MessageQueue的对象；主线程创建时自动创建Looper和MessageQueue，工作线程需要手动创建。
- Handler如果不指定Looper则自动绑定同线程的Looper
- MQ创建完成后，Looper自动进入消息循环
消息入队
Handler将Message发送到与自己绑定的Looper的MessageQueue
消息循环
- 消息出队：Looper循环取出MQ中的Message
- 消息分发：Looper将取出的Message发送给与自己绑定的Handler们
在消息循环的过程中，如果MQ为空了，线程会阻塞
消息处理
Handler拿到Looper发来的Message后执行操作
下面是Handler实现简单线程通信的示意图：
源码分析
Handler
创建Handler
//经常使用的构造器
public Handler() {
this(null, false);
}
//指定Looper的构造器
public Handler(Looper looper) {
this(looper, nuul, false);
}
public Handler(Callback callback, boolean async) {
...
1.指定Looper对象，因为没有指定Looper，所以绑定当前线程的Looper
mLooper = Looper.myLooper();
Handler必须绑定一个Looper对象否则抛异常；所以工作线程中创建Handler之前必须先创建Looper对象
if (mLooper == null) { throw new RuntimeException(); }
2.绑定消息队列对象
mQueue = mLooper.mQueue;
}
public Handler(Looper looper, Callback callback, boolean async) {
...
1.指定Looper对象，因为指定了Looper对象，所以可以直接绑定
mLooper = looper;
2.绑定消息队列对象
mQueue = looper.mQueue;
}
发送消息
//sendMessage
public final boolean sendMessage(Message msg) {
return sendMessageDelayed(msg, 0);
}
//post
public final boolean post(Runnable r) {
return sendMessageDelayed(getPostMessage(r), 0);
}
private static Message getPostMessage(Runnable r) {
Message m = Message.obtain();
m.callback = r;
return m;
}
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) {
发送消息前先获取到与Handler绑定的Looper对象持有的MQ
MessageQueue queue = mQueue;
MQ对象必须有，否则无法发送消息
if (queue == null) { return false; }
return enqueueMessage(queue, msg, uptimeMillis);
}
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
Handler把消息发送到MQ
return queue.enqueueMessage(msg, uptimeMillis);
}
分发、处理消息
public void dispatchMessage(Message msg) {
1.处理post方法发出的消息
if (msg.callback != null) {
handleCallback(msg);//也就是回调Runnable中的run方法
} else {
...
2.处理sendMessage方法发出的消息
handleMessage(msg);
}
}Looper
创建Looper对象
public static void prepare() {
prepare(true);
}
public static void prepareMainLooper() {
1.在android系统启动时，会默认创建一个主线程也叫UI线程ActivityThread，会自动调用它的main方法
prepare(false);
...
sMainLooper = myLooper();
}
private static void prepare(boolean quitAllowed) {
1.先判断当前线程中有没有Looper对象，因为一个线程只能有一个Looper对象，所以该方法只能调用一次
if (sThreadLocal.get() != null) {
throw "Only one Looper may be created per thread"
}
2.将Looper对象存放到Thread里
sThreadLocal.set(new Looper(quitAllowed));
}
private Looper(boolean quitAllowed) {
1.只要创建了Looper就自动创建了MQ对象
mQueue = new MessageQueue(quitAllowed);
...
mThread = Thread.currentThread();
}
开启消息循环
public static void loop() {
1.获取当前Looper的消息队列
final Looper me = myLooper();
final MessageQueue queue = me.mQueue;
...
2.消息循环
for(;;) {
2.1 从消息队列中取出消息
Message msg = queue.next();
if (msg == null) {//若取出的消息为空，则线程阻塞
return;
}
2.2 派发消息到对应的Handler
msg.target.dispatchMessage(msg);//把消息派发给message的target属性；target属性实际就是一个Handler对象
3.释放消息占据的资源
msg.recycleUnchecked();//其实就是将message里面的属性都赋值0或null
}
}
MessageQueue
Message next() {
...
1.用于标识队中是否还有消息 0：还有 -1：没了
int nextPollTimeoutMillis = 0;
for (;;) {
if (nextPollTimeoutMillis != 0) {
Binder.flushPendingCommands();
}
2.如果nextPollTimeoutMillis等于-1，队列处于等待状态
nativePollOnce(ptr, nextPollTimeoutMillis);
synchronized (this) {
...
if (msg != null) {
...
3.消息出队
return msg;
} else {
4.没有消息了
nextPollTimeoutMillis = -1;
}
}
}
}
boolean enqueueMessage(Message msg, long when) {
...
synchronized(this) {
msg.markInUse();
msg.when = when;
Message p = mMessages;
boolean needWake;
1.判断消息队列里有没有消息
if (p == null || when = 0 || when < p.when) {
2.若没有消息，将当前插入消息作为队头；若此消息队列处于阻塞态，则唤醒
msg.next = p;
mMessages = msg;
needWake = mBlocked;
} else {
...
for(;;) {
3.若有消息，根据消息创建时间插入队列
}
}
}
}Message
public static Message obtain() {
1.Message内部维护了一个Message池，用于Message对象的复用，使用obtain方法就是直接从池内获取
synchronized (sPoolsSync) {
if (sPool != null) {
Message m = sPool;
sPool = m.next;
m.next = null;//Message是链表？
m.flags = 0;
sPoolSize--;
return m;
}
}
2.若池内无消息对象可用，则还是用关键字new创建
return new Message();
}
Message内部有很多属性，比如target是Handler等等，可以好好看看ActivityThread
public static void main(String[] args) {
...
1.默认为主线程创建一个Looper对象，同时生成一个MQ对象
Looper.prepareMainLooper();
2.创建主线程
ActivityThread thread = new ActivityThread();
3.开启消息循环
Looper.loop();
}Handler底层执行方法的流程
