1 前言
Handler 即处理器，常用于跨线程通讯：线程A 和线程 B 拥有同一个 handler 对象，在线程 A 中使用 handler 的 sendMessage() 方法发送消息，在线程 B 中使用 handler 的 handleMessage() 方法处理消息。
Handler 家族主要有：Message、Handler、MessageQueue、Looper。
（1）应用场景
- 子线程处理完耗时操作后，请求主线程更新 UI
- 线程 A 定时给线程 B 发送消息
- 线程 A 周期性给线程 B 发送消息
（2）Handler 家族
- Message：消息类，通过 obtain() 方法可以生成一个 message 对象，每个 message 对象必须有一个 handler 对象；
- Handler：消息处理器，用于生成（obtainMessage）和处理消息（handleMessage）；
- MessageQueue：消息队列，用于存储消息，通过 enqueueMessage() 放入消息，next() 取出消息；
- Looper：循环器，用于取出消息，并通知 handler 执行消息。
（3）Handler 机制基本原理
假设在线程 A 中创建了 handler 对象，重写了 handler 的 handleMessage() 方法，并且将 handler 对象传给了线程 B，则线程 B 和线程 A 间的通讯如下：
- 生成消息：线程 B 通过 handler.obtainMessage() 生成消息（内部会调用 Message.abtain() 方法，并且会把当前 handler 传给 message 对象）；
- 发送消息：线程 B 通过 handler.sendMessage() 发送消息，再调用 mQueue.enqueueMessage() 将消息放入消息队列；
- 取出消息：线程A 中 mLooper 对象的 loop() 方法一直循环执行（若 mQueue 中没数据会等待），其内部会调用 mQueue 对象的 next() 方法，取出一个消息 msg；
- 执行任务：线程 A 中取出的 msg 对象在创建时已绑定 handler，通过调用 msg.target.dispatchMessage() 方法，通知 handler 执行 handleMessage() 方法。
2 Handler 机制源码解析
2.1 Message
（1）类图
（2）生成消息
public static Message obtain() {
synchronized (sPoolSync) {
if (sPool != null) {
Message m = sPool;
sPool = m.next;
m.next = null;
m.flags = 0; // clear in-use flag
sPoolSize--;
return m;
}
}
return new Message();
}
public static Message obtain(Handler h) {
Message m = obtain();
m.target = h;
return m;
}
sPool 是可用的空消息对象池 ，其本质是链表，sPool 指向链表的头结点，next 指向下一个节点。
（3）处理消息
msg.target.dispatchMessage(msg)
//最终会执行如下一种
msg.callback.run()
handler.mCallback.handleMessage(msg)
handler.handleMessage(msg)
target 是 Message 绑定的 handler 对象。
2.2 Handler
（1）类图
（2）Looper 对象的获取
若 handler 在主线程中创建，则不需要显式地给 handler 传递 Looper 对象。在主线程被创建时，系统会为主线程创建 Looper 对象，并开启消息循环。
public Handler() {
this(null, false);
}
public Handler(Handler.Callback callback, boolean async) {
...
mLooper = Looper.myLooper(); //获取与当前线程绑定的Looper对象
...
mQueue = mLooper.mQueue;
...
}
若 handler 在子线程中创建，则需要显示地传递 looper 对象，因为子线程在创建时不会创建 Looper 对象。
public Handler(Looper looper) {
this(looper, null, false);
}
public Handler(Looper looper, Handler.Callback callback, boolean async) {
mLooper = looper;
mQueue = looper.mQueue;
...
}
（3）生成消息
public final Message obtainMessage() {
return Message.obtain(this);
}
将 this 赋值给 message.target，与 message 对象绑定。
（4）发送消息
public final boolean sendMessage(Message msg) {
return sendMessageDelayed(msg, 0);
}
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;
...
return enqueueMessage(queue, msg, uptimeMillis);
}
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
msg.target = this;
if (mAsynchronous) {
msg.setAsynchronous(true);
}
return queue.enqueueMessage(msg, uptimeMillis);
}
从 enqueueMessage() 方法中可以看到，在消息入队之前，将 this 赋值给了 msg，确保每个 msg 都能绑定一个 handler。
（5）发送任务
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;
}
可以看到，即使发送的是 runnable，也会封装为 message。
（6）处理消息
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}
private static void handleCallback(Message message) {
message.callback.run();
}
public void handleMessage(Message msg) {
}
public interface Callback {
public boolean handleMessage(Message msg);
}
从 dispatchMessage() 方法中可以看到，处理消息的次序为：
- msg.callback.run()
- mCallback.handleMessage(msg)
- handleMessage(msg)
2.3 MessageQueue
（1）类图
（2）存储消息
boolean enqueueMessage(Message msg, long when) {
synchronized (this) {
...
Message p = mMessages;
boolean needWake;
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;
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); //唤醒 looper
}
}
return true;
}
mMessages 是消息队列的链头。
（3）取出消息
Message next() {
...
int nextPollTimeoutMillis = 0;
for (;;) {
...
nativePollOnce(ptr, nextPollTimeoutMillis); //等待
synchronized (this) {
final long now = SystemClock.uptimeMillis();
Message prevMsg = null;
Message msg = mMessages;
if (msg != null && msg.target == null) {
do {
prevMsg = msg;
msg = msg.next;
} while (msg != null && !msg.isAsynchronous());
}
if (msg != null) {
if (now < msg.when) {
nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);
} else { //取出消息
...
if (prevMsg != null) {
prevMsg.next = msg.next;
} else {
mMessages = msg.next;
}
msg.next = null;
...
return msg;
}
}
...
}
...
}
}
2.4 Looper
（1）类图
（2）创建 Looper 对象
public static void prepare() {
prepare(true);
}
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)); //创建Looper对象，并与当前线程绑定
}
（3）创建 MessageQueue
private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}
（4）循环
public static void loop() {
final Looper me = myLooper();
...
final MessageQueue queue = me.mQueue;
...
for (;;) {
Message msg = queue.next(); //可能会等待
...
msg.target.dispatchMessage(msg); //处理消息
...
msg.recycleUnchecked(); //回收消息
}
}
3 应用
3.1 应用一
（1）主线程（处理消息）
Handler handler = new Handler() {
@Override
public void handleMessage(Message msg) {
System.out.println("打印消息");
}
};
（2）子线程（发送消息）
handler.sendEmptyMessage(0x111);
3.2 应用二
（1）主线程（处理消息）
Handler handler = new Handler();
（2）子线程（发送消息）
handler.post(new Runnable() {
@Override
public void run() {
System.out.println("打印消息");
}
});
4 拓展
第3节中的案例都是子线程给主线程发送消息，但是某些场景需要主线程给子线程发送消息，或2个子线程间发送消息。默认情况下，系统会为主线程创建 Looper 对象，并开启消息循环，但新建的子线程中不会创建 Looper 对象，此时，就需要应用到 HandlerThread 类。
（1）HandlerThread 类图
（2）HandlerThread 核心源码
// 消息循环，通过threadHandler.start()开启循环
public void run() {
mTid = Process.myTid();
Looper.prepare(); //创建looper对象，并与当前线程绑定
synchronized (this) {
mLooper = Looper.myLooper();
notifyAll();
}
Process.setThreadPriority(mPriority);
onLooperPrepared();
Looper.loop(); //消息循环
mTid = -1;
}
//获取handler，并注入mLooper
public Handler getThreadHandler() {
if (mHandler == null) {
mHandler = new Handler(getLooper());
}
return mHandler;
}
（3）应用
线程 A（处理消息）
HandlerThread handlerThread = new HandlerThread("A");
handlerThread.start();
//Handler handler = handlerThread.getThreadHandler();
Handler handler = new Handler(handlerThread.getLooper());
线程 B（发送消息）
handler.post(new Runnable() {
@Override
public void run() {
System.out.println("打印消息");
}
});
声明：本文转自【Android】Message、Handler、MessageQueue、Looper 详解
标签：MessageQueue,handler,Handler,线程,Looper,msg,Message From： https://www.cnblogs.com/zhyan8/p/17233630.html