如需转载请评论或简信，并注明出处，未经允许不得转载
目录
前言
想必大家第一次接触Handler应该是在网络请求成功，需要通过接口数据进行UI渲染的时候。我们都知道，网络请求一定要在子线程中进行，否则就有可能出现ANR（Application Not Response），而Android一定要在主线程访问UI，借用Android官方的一句话
The Android UI toolkit is not thread-safe and the view must always be manipulated on the UI thread.
所以这时候就需要用Handler将数据信息发送到主线程，然后在主线程更新UI，从而保证了线程安全
Handler机制核心类
那么到底Handler是如何工作的才能保证线程安全呢？下面放一个Handler机制的模型图，先来对Handler机制有一个整体的认识。其实整个Handler机制中最重要的就是四个类Handler、Looper、MessageQueue、Message，我们先对这四个类进行一个初步的认识
Handler机制工作原理图
-
Message：
Handler接收和处理消息的对象 -
Looper：轮询读取
MessageQueue中的Message，并将Message交给Handler处理，每一个线程只能有一个Looper，它是线程持有的 -
MessageQueue：采用先进先出的方式管理
Message -
Handler：发送和处理
Message，如果希望Handler能正常工作，就必须在当前线程有一个Looper对象
从源码分析Handler机制
我们先来看Handler的构造方法
public Handler(Callback callback, boolean async) {
...
mLooper = Looper.myLooper();
if (mLooper == null) {
throw new RuntimeException(
"Can't create handler inside thread that has not called Looper.prepare()");
}
mQueue = mLooper.mQueue;
...
}
Handler在构造方法中通过Looper.myLooper()拿到一个Looper对象
/**
* Return the Looper object associated with the current thread. Returns
* null if the calling thread is not associated with a Looper.
*/
public static @Nullable Looper myLooper() {
return sThreadLocal.get();
}
可以看出，Looper是从ThreadLocal对象中取出的，ThreadLocal是单线程内共享资源的工具类，很多地方也称之为线程本地变量，具体可以看彻底理解ThreadLocal
那Looper是何时被存入ThreadLocal对象中的呢？我们找到了Looper.prepare()，从这个方法中可以看出，每个线程只能创建一个Looper，不然就会抛出异常，那么这个方法是在哪里被调用的呢？
private static void prepare(boolean quitAllowed) {
if (sThreadLocal.get() != null) {
throw new RuntimeException("Only one Looper may be created per thread");
}
sThreadLocal.set(new Looper(quitAllowed));
}
App启动的时候，会在ActivityThread的main方法中调用Looper.prepareMainLooper()在主线程中创建一个Looper对象，Looper.prepareMainLooper()内部调用的实际上就是Looper.prepare()
所以读到这里我们知道了，在App启动的时候，主线程会主动调用Looper.prepare()创建当前线程的Looper对象，当我们需要使用主线程中的Looper对象时，只需要调用Looper.myLooper()，而Hander内部就是这么做的，所以我们可以在主线程中直接使用Handler。由此可知，如果我们想在子线程中创建并使用Handler，必须要主动调用Looper.prepare()
public static void main(String[] args) {
...
Looper.prepareMainLooper();
ActivityThread thread = new ActivityThread();
thread.attach(false);
if (sMainThreadHandler == null) {
sMainThreadHandler = thread.getHandler();
}
...
Looper.loop();
throw new RuntimeException("Main thread loop unexpectedly exited");
}
Looper对象已经创建完成，接下来我们来看看Handler是如何发送消息的，发送消息一般有两种方式
handler.sendMessage(Message msg)
public final boolean sendMessage(Message msg){
return sendMessageDelayed(msg, 0);
}
handler.post(Runnable r)
public final boolean post(Runnable r){
return sendMessageDelayed(getPostMessage(r), 0);
}
//将Runnable装入Message进行消息传递
private static Message getPostMessage(Runnable r) {
Message m = Message.obtain();
m.callback = r;
return m;
}
其实这两种方式都是通过sendMessageDelayed()发送消息，并且最终都会通过MessageQueue的enqueueMessage(Message msg, long uptimeMillis)发送消息，这样就完成了一个Handler往消息队列中存放消息的过程。那么Handler中的MessageQueue对象是什么时候被创建的呢？
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);
}
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
msg.target = this;
if (mAsynchronous) {
msg.setAsynchronous(true);
}
//最终调用MessageQueue的enqueueMessage()
return queue.enqueueMessage(msg, uptimeMillis);
}
从Handler的构造方法中可以看出，MessageQueue对象是从Looper对象中的全局变量中取出的，查看源码发现MessageQueue就是在Looper的构造方法中被创建的。所以MessageQueue也是在App初始化的时候就创建好了，且每个线程只会存在一个MessageQueue实例
private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}
虽然MessageQueue被称为消息队列，但实际上他并不是队列，而是以单链表的方式实现的，因为单链表在插入和删除上有优势
MessageQueue最主要的方法有两个，一个是enqueueMessage(Message msg, long when)，另一个是next()，分别代表了Message的插入和删除操作
messageQueue.enqueueMessage(Message msg, long when)
/**入队，即 将消息 根据时间 放入到消息队列中**/
boolean enqueueMessage(Message msg, long when) {
...// 仅贴出关键代码
synchronized (this) {
msg.markInUse();
msg.when = when;
Message p = mMessages;
boolean needWake;
// 判断消息队列里有无消息
// a. 若无，则将当前插入的消息 作为队头 & 若此时消息队列处于等待状态，则唤醒
if (p == null || when == 0 || when < p.when) {
msg.next = p;
mMessages = msg;
needWake = mBlocked;
} else {
needWake = mBlocked && p.target == null && msg.isAsynchronous();
Message prev;
// b. 判断消息队列里有消息，则根据 消息（Message）创建的时间 插入到队列中
for (;;) {
prev = p;
p = p.next;
if (p == null || when < p.when) {
break;
}
if (needWake && p.isAsynchronous()) {
needWake = false;
}
}
msg.next = p;
prev.next = msg;
}
if (needWake) {
nativeWake(mPtr);
}
}
return true;
}
messageQueue.next()
/**出队消息，即从 消息队列中 移出该消息**/
Message next() {
...// 仅贴出关键代码
// 该参数用于确定消息队列中是否还有消息
// 从而决定消息队列应处于出队消息状态 or 等待状态
int nextPollTimeoutMillis = 0;
for (;;) {
if (nextPollTimeoutMillis != 0) {
Binder.flushPendingCommands();
}
// nativePollOnce方法在native层，若是nextPollTimeoutMillis为-1，此时消息队列处于等待状态
nativePollOnce(ptr, nextPollTimeoutMillis);
synchronized (this) {
final long now = SystemClock.uptimeMillis();
Message prevMsg = null;
Message msg = mMessages;
// 出队消息，即 从消息队列中取出消息：按创建Message对象的时间顺序
if (msg != null) {
if (now < msg.when) {
nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);
} else {
// 取出了消息
mBlocked = false;
if (prevMsg != null) {
prevMsg.next = msg.next;
} else {
mMessages = msg.next;
}
msg.next = null;
if (DEBUG) Log.v(TAG, "Returning message: " + msg);
msg.markInUse();
return msg;
}
} else {
// 若 消息队列中已无消息，则将nextPollTimeoutMillis参数设为-1
// 下次循环时，消息队列则处于等待状态
nextPollTimeoutMillis = -1;
}
......
}
.....
}
}
前面我们说到了Looper的作用是轮询读取MessageQueue中的Message，messageQueue.next()就是在Looper.loop()中被调用的
/**
* Run the message queue in this thread. Be sure to call
* {@link #quit()} to end the 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;
...
for (;;) {
//从消息队列中取出Message
Message msg = queue.next(); // might block
if (msg == null) {
// No message indicates that the message queue is quitting.
return;
}
//派发发消息到对应的Handler,target就是Handler的实例
msg.target.dispatchMessage(msg);
....
//释放消息占据的资源
msg.recycleUnchecked();
}
}
可以看出Looper.loop()内部是一个死循环。Android应用是由事件驱动的，Looper.loop()不断的轮询接收事件，handler不断的处理事件。每一个点击触摸事件，或者Activity的生命周期的创建，都是运行在Looper.loop()控制之下，简单的来说就是，这些都是属于一个事件消息，然后由Looper.loop()轮询到，接着做相应的操作，MessageQueue中的Message最终会根据出队消息的归属者通过dispatchMessage(msg)进行分发
/**
* Handle system messages here.
*/
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}
回调重写的handleMessage(Message msg)，从而实现 消息处理 的操作。因为handleMessage是在主线程中执行，所以这些事件消息的处理，可能会卡顿，造成Looper.loop()循环的阻塞。当Looper.loop()没有轮询到事件的时候，整个应用程序就退出了，而我们的消息事件都是在Looper.loop()循环内，如果循环内没有得到及时的处理事件，就会造成了ANR
特别注意：在进行消息分发时，会进行1次发送方式的判断：
- 若
msg.callback属性不为空，则代表使用了post（Runnable r）发送消息，则直接回调Runnable对象里复写的run（） - 若
msg.callback属性为空，则代表使用了sendMessage（Message msg）发送消息，则回调复写的handleMessage(msg)
Handler机制流程总结
为主线程创建一个Looper对象，在创建Looper对象的同时，会在Looper的构造方法内创建MessageQueue对象。在创建Handler对象的时候，会取出当前线程的Looper，通过Looper不断的去轮询MessageQueue中的Mesage。Handler在子线程中sendMessage(Message msg)或post(Runnable r)实际上就是往MessageQueue中添加一条消息，最后通过Looper中的消息循环将Message取出交给Handler去处理
Handler是线程间数据传输的一种工具，它不仅仅可以将消息从子线程传递给主线程，如果我们想将主线程的消息传递给子线程，其实也是可以的，我们只需要保证handler.handleMessage(msg)的线程与Handler中Looper对象创建的线程一致。也就是说，我们可以在子线程中调用Looper.prepare()并创建Handler对象，然后在主线程中调用handler.sendMessage(msg)，这样handler.handleMessage(msg)就会在子线程进行回调。Android中为了方便我们在子线程中使用Handler，帮我们封装了Thread和Looper，避免了手动操作Looper，有兴趣的可以看HandlerThread使用及源码解析
网友评论