一、作用
轻松地将一个任务切换到 Handler 所在线程去执行。可用于发送消息和处理消息。
二、概念
0. Android 消息机制及源码分析
- Handler
用于发送和处理消息。
一个线程中可有多个 Handler。
- MessageQueue
消息队列，用于存放通过 Handler 发送的消息，等待被处理。
Looper 中维护一个 MessageQueue，一个线程只有一个 MessageQueue
- Looper
Looper 是 MessageQueue 的管家，调用Looper.loop()方法后，就会进入到无限循环中，每当发现 MessageQueue 中存在一条消息，就将他取出，并传递给 Handler 处理。
每个线程只能有一个 Looper，Looper 保存在 ThreadLocal 中。主线程已经创建了 Looper 不需要再手动创建，其他线程的 Looper 需手动创建。
1. 发送消息 API
Android：这是一份Handler消息传递机制 的使用教程
消息的发送有 2 种方式
（1）post 的一系列方法
/**
* 将runnable添加到消息队列中， runnable 将在该Handler绑定的thread运行
*
* @param r
* @return
*/
public final boolean post(Runnable r) {
return sendMessageDelayed(getPostMessage(r), 0);
}
/**
* 将runnable添加到消息队列中，在指定时间（<var>uptimeMillis</var>）运行， runnable 将被该Handler绑定的thread运行
*
* @param r
* @param uptimeMillis @return：true：当runnable被正确添加到消息队列中；false：通常是由于处理消息队列的Looper正在退出。
* 注意：返回值为true，不代表runnable会被执行（例如：在消息被执行之前Looper退出了，那么该消息将被dropped丢弃）
*/
public final boolean postAtTime(Runnable r, long uptimeMillis) {
return sendMessageAtTime(getPostMessage(r), uptimeMillis);
}
/**
* 将runnable添加到消息队列中，在指定时间（<var>uptimeMillis</var>）运行，
*
* @param r
* @param token
* @param uptimeMillis
* @return
*/
public final boolean postAtTime(Runnable r, Object token, long uptimeMillis) {
return sendMessageAtTime(getPostMessage(r, token), uptimeMillis);
}
/**
* 将runnable添加到消息队列，在指定时间后执行
*
* @param r
* @param delayMillis
* @return
*/
public final boolean postDelayed(Runnable r, long delayMillis) {
return sendMessageDelayed(getPostMessage(r), delayMillis);
}
/**
* 这个方法在极特殊的情况下才调用，可能导致side-effects
*
* @param r
* @return
*/
public final boolean postAtFrontOfQueue(Runnable r) {
return sendMessageAtFrontOfQueue(getPostMessage(r));
}
（2）send 的一系列方法
public final boolean sendMessage(Message msg) {
return sendMessageDelayed(msg, 0);
}
public final boolean sendEmptyMessage(int what) {
return sendEmptyMessageDelayed(what, 0);
}
public final boolean sendEmptyMessageDelayed(int what, long delayMillis) {
Message msg = Message.obtain();
msg.what = what;
return sendMessageDelayed(msg, delayMillis);
}
public final boolean sendEmptyMessageAtTime(int what, long uptimeMillis) {
Message msg = Message.obtain();
msg.what = what;
return sendMessageAtTime(msg, uptimeMillis);
}
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);
}
public final boolean sendMessageAtFrontOfQueue(Message msg) {
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, 0);
}
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
msg.target = this;
if (mAsynchronous) {
msg.setAsynchronous(true);
}
return queue.enqueueMessage(msg, uptimeMillis);
}
2. 移除消息
？？？？
/**
* Remove any pending posts of Runnable r that are in the message queue.
*/
public final void removeCallbacks(Runnable r) {
mQueue.removeMessages(this, r, null);
}
/**
* Remove any pending posts of Runnable <var>r</var> with Object
* <var>token</var> that are in the message queue. If <var>token</var> is null,
* all callbacks will be removed.
*/
public final void removeCallbacks(Runnable r, Object token) {
mQueue.removeMessages(this, r, token);
}
/**
* Remove any pending posts of messages with code 'what' that are in the
* message queue.
*/
public final void removeMessages(int what) {
mQueue.removeMessages(this, what, null);
}
/**
* Remove any pending posts of messages with code 'what' and whose obj is
* 'object' that are in the message queue. If <var>object</var> is null,
* all messages will be removed.
*/
public final void removeMessages(int what, Object object) {
mQueue.removeMessages(this, what, object);
}
/**
* Remove any pending posts of callbacks and sent messages whose
* <var>obj</var> is <var>token</var>. If <var>token</var> is null,
* all callbacks and messages will be removed.
*/
public final void removeCallbacksAndMessages(Object token) {
mQueue.removeCallbacksAndMessages(this, token);
}
三、重点了解
1. Q：为什么在没有 Looper 的线程中创建 Handler 会引起异常
Handler 的构造函数
public Handler() {
this(null, false);
}
public Handler(Callback callback) {
this(callback, false);
}
public Handler(Looper looper) {
this(looper, null, false);
}
public Handler(Looper looper, Callback callback) {
this(looper, callback, false);
}
public Handler(boolean async) {
this(null, async);
}
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());
}
}
mLooper = Looper.myLooper();
if (mLooper == null) {
throw new RuntimeException(
"Can't create handler inside thread that has not called Looper.prepare()");
}
mQueue = mLooper.mQueue;
mCallback = callback;
mAsynchronous = async;
}
/**
* 异步消息表示不需要相对于同步消息进行全局排序的中断或事件
*
* Handler默认是同步的，除非通过参数async明确指定它是异步的
* @param looper：使用提供的 Looper 而不是默认的Looper，必须不为空
* @param callback：使用提供的callback处理消息，可以为null
* @param async:
*/
public Handler(Looper looper, Callback callback, boolean async) {
mLooper = looper;
mQueue = looper.mQueue;
mCallback = callback;
mAsynchronous = async;
}
通过2个参数的构造函数可知，如果当前线程没有 Looper 的话，就会抛出异常，这也就解释了在没有 Looper 的子线程创建 Handler 会引起异常。
2. Q：Handler 如何处理消息
对消息的处理最终会回调到 Handler 的
dispatchMessage()中。
/**
* 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);
}
}
从源码可得，
- 若是通过
post方式发送的消息（该方式发送消息时会传入Runnable实例）
则直接在 Handler 所在线程中调用Runnable的run()
private static void handleCallback(Message message) {
message.callback.run();
}
- 若是
send方式发送的消息
检查mCallback是否为空，其中mCallback是个接口类型
/**
* 这是一个接口，可以在实例化 Handler 时使用。
* 好处：在日常开发中，创建 Handler 的常见方式是派生一个 Handler 子类并重写 handlerMessage()来处理具体的消息。
* 有了 Callback，为我们创建 Handler 提供了另外一种可用方式，使得我们不想派生子类时，可以通过 Callback 实现。
*
* @param msg A {@link android.os.Message Message} object
* @return True if no further handling is desired
*/
public interface Callback {
public boolean handleMessage(Message msg);
}
Handler 提供了带Callback的构造函数，mCallback即为构造函数中传入的。
/**
* 该构造函数将 Handler 和当前线程联系起来，Callback用于处理消息
*
* 如果当前线程没有 Looper，Handler 不可接收消息，并且会抛出异常
*
* @param callback The callback interface in which to handle messages, or null.
*/
public Handler(Callback callback) {
this(callback, false);
}
mCallback不为空：调用mCallback.handleMessage(msg)
mCallback为空：调用Handler::handleMessage(msg)（该方法由 Handler 派生的子类重写，以处理消息）。
3. 获取 Message 的2种方式的比较
2种方式
推荐使用
Message.obtain()：从全局消息池中返回一个新的消息实例，在多数情况下可以避免分配新对象。
三、使用
1. Handler 的创建
- 创建子类继承
Handler，重写handleMessage()
// 在主线程中创建实例
private MyHandler mHandler = new MyHandler();
private static class MyHandler extends Handler {
@Override
public void handleMessage(@NonNull Message msg) {
super.handleMessage(msg);
switch (msg.what) {
case 1:
break;
default:
break;
}
}
}
- 匿名内部类
// 在主线程中创建
private Handler mHandler = new Handler() {
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
System.out.println(msg.what);
}
};
2.发送消息
- post
post 方法将一个 Runnable 投递到 Handler 内部的 Looper 中去处理，
mHandler.post(new Runnable() {
@Override
public void run() {
... // 需在目标线程中执行的操作（如：更新UI）
}
});
- send
// 实例化消息对象
Message msg = Message.obtain();
msg.what = 1; // 消息标识
msg.obj = "AA"; // 消息内容存放
mHandler.sendMessage(msg);
