概述#
| 类 | 说明 |
|---|---|
| Handler | 真正处理事件的地方 |
| Looper | 循环检查是否有要传输的事件，从 MessageQueue 中获取事件，并交给 Handler 处理（假如列队为空就进入休眠） |
| MessageQueue | 储存需要做的事情，一般来说只允许保存相同类型的 Object、Message 除存的数据结构队列 |
| Message | 需要做的事件 |
一个 Thread 对应一个 Looper
一个 Looper 对应一个 MessageQueue
一个 MessageQueue 内有多个 Message
每个 Message 中最多对应一个 Handler 处理事件
Thread & Handler 是一对多的关系
Handler#
接受处理 Messgae
将 Message 存入 MessageQueue 中
// Handler.java
public class Handler {
...
final Looper mLooper;
final MessageQueue mQueue;
final Callback mCallback;
...
public interface Callback {
boolean handleMessage(@NonNull Message msg);
}
// 通常用来给使用者 Override 处理事件
public void handleMessage(@NonNull Message msg) {
}
// 分化，有三种方式
public void dispatchMessage(@NonNull Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}
}
在上面分发事件有三种方法，并且 这三种分发方式有先后顺序，只要前面被处理，就不会使用后面的方式处理
Message 本身的 callback
实现 Callback 接口
Override Handler#handleMessage Function
通过 Handler 把信息入队到 MessageQueue，方式有 Post & Send 两种系列，并且可以控制发送的时间
Post 系列：把零散信息转为 Message 再用 Send 传出
| 函数 | 功能 |
|---|---|
| boolean post(Runnable r) | 直接发出信息 |
| boolean postAtTime(Runnable, long updatetimeMillis) | 在固定（规定）时间再发出该条信息 |
| Send 系列：参数直接是 Message |
| 函数 | 功能 |
|---|---|
| boolean sendEmptyMessage(int what) | 直接发送信息 |
| boolean sendMessageArFrontOfQueue(Message msg) | 把消息发送到信息队列最前面 |
| boolean sendMessageAtTime(int what, long updatetimeMillis) | 在固定（规定）时间再发出该条信息 |
| boolean sendMessageDelayed(Message msg, long delayMillis) | 延迟几毫秒后发送该信息 |
Post 实现方式
// Handler.java
public class Handler {
public final boolean post(@NonNull Runnable r) {
return sendMessageDelayed(getPostMessage(r), 0);
}
// 包装 callback 再传出
private static Message getPostMessage(Runnable r) {
Message m = Message.obtain(); // 取得 Message 资源，避免不断创建，可以复用资源
m.callback = r; // 直接设定 Runnable 回调函数
return m;
}
// 最后通过计算 当前时间 + 延长实现，之后就呼叫 sendMessageAtTime 函数
public final boolean sendMessageDelayed(@NonNull Message msg, long delayMillis) {
if (delayMillis < 0) {
delayMillis = 0;
}
return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
}
// 在规定时间发送信息
public boolean sendMessageAtTime(@NonNull Message msg, long uptimeMillis) {
MessageQueue queue = mQueue;
if (queue == null) {
// 若是该 Thread 并没有规定 MessageQueue 则会抛出错误
RuntimeException e = new RuntimeException(
this + " sendMessageAtTime() called with no mQueue");
Log.w("Looper", e.getMessage(), e);
return false;
}
return enqueueMessage(queue, msg, uptimeMillis);
}
}
发送信息方法#
| 名称 | 参数：回传 | 解释 |
|---|---|---|
| post | Runnable : boolean | 接收一个 Runnable 对象作为 Message |
| postAtTime | Runnable, long : boolean | 接收一个 Runnable 对象作为 Message，并在等待的规定时间发送 Message |
| sendEmptyMessage | int : boolean | 发送一个使用者规定的 int 信息，在由使用者自己处理 |
| sendMessageAtTime | Messge, int : boolean | 发送一个使用者规定的 int 信息，在由使用者自己处理 |
| sendMessageDelayed | Messge, long : boolean | 在等待的规定时间后 (延迟) 发送 Message |
Post & Send#
// Send ...
public final boolean sendEmptyMessageDelayed(int what, long delayMillis) {
Message msg = Message.obtain();
msg.what = what;
return sendMessageDelayed(msg, delayMillis);
}
// 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;
}
// 最终都会 sendMessageAtTime
public boolean sendMessageAtTime(Message msg, long uptimeMillis) {
MessageQueue queue = mQueue;
if (queue == null) { // 1.
RuntimeException e = new RuntimeException(
this + " sendMessageAtTime() called with no mQueue");
Log.w("Looper", e.getMessage(), e);
return false;
}
return enqueueMessage(queue, msg, uptimeMillis);
}
处理 Message#
从 dispatchMessage 可看出它预设处理 Message 的顺序
msg.callback (Runnable)
mCallback (interface)
handleMessage (method)
public void handleMessage(Message msg) {
// 使用者复写
}
/**
* Handle system messages here.
*/
public void dispatchMessage(Message msg) {
// callback 优先级最高
if (msg.callback != null) { // msg.callback is Runnable
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}
MessageQueue & Message#
如其名，它是一个队列 FIFO，它通过 本地方法 (Native) 内存指针创建 Queue
private native static long nativeInit();
MessageQueue(boolean quitAllowed) {
mQuitAllowed = quitAllowed;
mPtr = nativeInit();
}
Queue 方法#
| 名称 | 参数：回传 | 解释 |
|---|---|---|
| enqueueMessage | Message, long : boolean | 在指定时间内压入队列中 |
| next | void : Message | 元素拉出队列 |
| removeMessages | Handler, int, Object : void | 移除特定元素 |
| removeMessages | Handler, Runnable, Object : void | 移除特定元素 |
MessageQueue#
MessageQueue 因为是 Queue 所以有所谓的 FIFO, 所以有队列的功能
MessageQueue(boolean quitAllowed) {
mQuitAllowed = quitAllowed;
mPtr = nativeInit();
}
private native static int nativeInit();
MessageQueue 创建#
连接于 Looper 的建构函数，当 Looper 创建时 MessageQueue 就一同创建
private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}
Looper 通过 MessageQueue 取得 Message#
// MessageQueue.java
Message next() {
// 若已经被 depose mPtr 就会被设定为 0
final long ptr = mPtr;
if (ptr == 0) {
return null;
}
int pendingIdleHandlerCount = -1; // -1 only during first iteration
// 下一个信息的时间
int nextPollTimeoutMillis = 0;
// 进入无限循环，也就是说 next 会导致 block
for (;;) {
... 省略部分
synchronized (this) {
// Try to retrieve the next message. Return if found.
final long now = SystemClock.uptimeMillis();
Message prevMsg = null; // 上一个信息
Message msg = mMessages; // 当前信息
if (msg != null && msg.target == null) { // target 就是 Handler
// 找到一个可发送的 Message
do {
prevMsg = msg;
msg = msg.next; // 切换到下一个 Message
} while (msg != null && !msg.isAsynchronous());
}
// 再次判断 Message
if (msg != null) {
// 判断时间
if (now < msg.when) { // 该信息的时间还没到
// Next message is not ready. Set a timeout to wake up when it is ready.
// 计算剩余时间
nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);
} else {
// 时间到，并且有 Message
mBlocked = false;
if (prevMsg != null) {
prevMsg.next = msg.next; // 上一个 Message 就是当前 Message
} else {
mMessages = msg.next; //切换到下一个要用的 Message
}
// 断开连接 !! 好让 GC 侦测到后回收 !!! (可达性分析)
msg.next = null;
... debug 訊息
msg.markInUse(); // 标记该 Message 已经被使用过
return msg;
}
} else {
// No more messages.
nextPollTimeoutMillis = -1;
}
// Process the quit message now that all pending messages have been handled.
if (mQuitting) { // 检查是否退出
dispose();
return null;
}
... 省略 IdleHandler
}
... 省略部分
}
IdleHandler#
IdleHandler 是 MessageQueue 内的一个 interface，它可以在 MessageQueue 没有消息时让使用者知道，并决定如何处理
// MessageQueue.java
public static interface IdleHandler {
// 返回true，会让你设定的接口继续存在
// 返回false则会移除你设定的接口
boolean queueIdle();
}
同样分析 next 方法，可以看到一个 MessageQueue 最多设定 4 个 IdleHandler
// MessageQueue.java
Message next() {
// 若已经被depose mPtr就会被设定为0
final long ptr = mPtr;
if (ptr == 0) {
return null;
}
int pendingIdleHandlerCount = -1; // -1 only during first iteration
// 下一个信息的时间
int nextPollTimeoutMillis = 0;
// 进入无限循环，也就是说next会导致block
for (;;) {
... 省略部分
synchronized (this) {
... 省略部分
// 检查是否有设置IdleHandler
if (pendingIdleHandlerCount < 0
&& (mMessages == null || now < mMessages.when)) {
pendingIdleHandlerCount = mIdleHandlers.size();
if (pendingIdleHandlerCount <= 0) {
// No idle handlers to run. Loop and wait some more.
mBlocked = true;
continue;
}
// 最多设置4个Idle Handler
if (mPendingIdleHandlers == null) {
mPendingIdleHandlers = new IdleHandler[Math.max(pendingIdleHandlerCount, 4)];
}
mPendingIdleHandlers = mIdleHandlers.toArray(mPendingIdleHandlers);
}
// 循环
for (int i = 0; i < pendingIdleHandlerCount; i++) {
final IdleHandler idler = mPendingIdleHandlers[i];
mPendingIdleHandlers[i] = null; // release the reference to the handler
boolean keep = false;
try {
// 当没有信息时通知接口
keep = idler.queueIdle();
} catch (Throwable t) {
Log.wtf(TAG, "IdleHandler threw exception", t);
}
// 返回 false 就移除
if (!keep) {
synchronized (this) {
mIdleHandlers.remove(idler);
}
}
}
... 省略部分
}
}
Looper#
它是组成消息的重要关键（Handler、Message、MessageQueue），它的角色是驱动
| 名称 | 参数：回传 | 解释 |
|---|---|---|
| myLooper | void : Looper | 以当前线程为主，取得当前 Thread 的 Looper |
| getMainLooper | void : Looper | 取得主线程的 Looper |
Looper - ThreadLocal#
最后 Looper 则是让整个 Hanler 机制循的动力，有 Looper 的推动 Handler 才能正常接收、发送信息
Looper 中包含了一个 MessageQueue（在构造函数中建构的）
// ava/android/os/Looper.java
public final class Looper {
// 私有函数
private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}
}
当你每创建一个线程就必须为这个线程准备 Looper，否则在 Handler 发送消息时就会 crush（上面有说到会检查），创建主要有以下步骤
Looper 准备工作（prepare 函数）
创建 Handler 发送＆接收消息
Looper 开始运作（loop 函数）
class LooperThread extends Thread {
private Handler handler;
public void run() {
// 1
Looper.prepare();
// 2.
handler = new Handler() {
@Override
public void handleMessage(Message msg) {
//... 处理 Message
}
}
// 3.
Looper.loop();
}
}
ThreadLocal 这里大概提及，ThreadLocal 也就是线程隔离，使用线程 Thread 作为 Key 储存，而 Value 就是你要拷贝到每个线程的数据（每个子线程都持有一个数据）
//android/os/Looper.java
public final class Looper {
// 拷贝线程的数据是Looper
static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
public static void prepare() {
prepare(true);
}
private static void prepare(boolean quitAllowed) {
if (sThreadLocal.get() != null) // 一个线程只能prepare一次
throw new RuntimeException("Only one Looper may be created per thread");
}
// 为当前Thread设定Looper
sThreadLocal.set(new Looper(quitAllowed));
}
}
当你建立一个 Handler 时，在 Handler construct 就会透过当前的线程取得 Looper
// Handler
public Handler(@Nullable Callback callback, boolean async) {
...
mLooper = Looper.myLooper();
if (mLooper == null) {
throw new RuntimeException(
"Can't create handler inside thread " + Thread.currentThread()
+ " that has not called Looper.prepare()");
}
mQueue = mLooper.mQueue;
mCallback = callback;
mAsynchronous = async;
}
// -----------------------------------------------------------------
// Looper
public static @Nullable Looper myLooper() {
// sThreadLocal是静态的，会透过当前Thread作为Key取得Looper
return sThreadLocal.get();
}
Looper & Handler#
Looper 跟 Handler 的关系可以从 new Handler（）这个构造函数中看出，它是透过 myLooper 方法，透过目前的线程在 ThreadLocal 中取得该当前线程所拥有的 Looper
// Handler construct
public Handler() {
this(null, false);
}
public Handler(Callback callback, boolean async) {
... 忽略
// 取得当前线程的 Loop
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;
}
//Looper...
public static @Nullable Looper myLooper() {
return sThreadLocal.get();
}
Looper & UI Thread#
Android 中 Activity 的主线程是 ActivityThread’s main ()
public static void main(String[] args) {
...
Looper.prepareMainLooper(); //"1. "
ActivityThread thread = new ActivityThread();
thread.attach(false);
if (sMainThreadHandler == null) {
//"2. "
sMainThreadHandler = thread.getHandler();
}
...
// End of event ActivityThreadMain.
...
Looper.loop();
throw new RuntimeException("Main thread loop unexpectedly exited");
}
主线程的 Looper 是不可以关闭的，并且使用类同步
public static void prepareMainLooper() {
prepare(false);
synchronized (Looper.class) {
if (sMainLooper != null) {
throw new IllegalStateException("The main Looper has already been prepared.");
}
sMainLooper = myLooper();
}
}
// 属性...
private static Looper sMainLooper; // guarded by Looper.class
Looper#loop，首先取得目前线程所拥有的 Looper，再取出 Looper 内部有的 MessageQueue，最后无限循环整个消息对列
// Looper.java
public static void loop() {
final Looper me = myLooper();
...
final MessageQueue queue = me.mQueue;
...
for (;;) {
//
Message msg = queue.next(); // might block
if (msg == null) {
// No message indicates that the message queue is quitting.
return;
}
...
try {
// 解决是谁再呼叫dispatchMessage，target为MessageQueue中的Handler
msg.target.dispatchMessage(msg);
end = (slowDispatchThresholdMs == 0) ? 0 : SystemClock.uptimeMillis();
} finally {
if (traceTag != 0) {
Trace.traceEnd(traceTag);
}
}
...
msg.recycleUnchecked();
}
}
ThreadLocal#
ThreadLocal 的功能主要是做到线程隔离（用线程隔离数据），简单来说可以把 ThreadLocal 当作一个 Map（但实际来说它并不是 Map），它的 Key 是 Thread，Value 是一个泛型
// 前面Looper.prepare（）内部就有使用到set（）方法
public void set(T value) {
Thread t = Thread.currentThread(); //"1. "
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);
else
createMap(t, value);
}
// 前面Handler（）构造函数内部就有使用到get（）方法
public T get() {
Thread t = Thread.currentThread(); //"2. "
ThreadLocalMap map = getMap(t);
if (map != null) {
ThreadLocalMap.Entry e = map.getEntry(this);
if (e != null) {
@SuppressWarnings("unchecked")
T result = (T)e.value;
return result;
}
}
return setInitialValue();
}
它使用目前呼叫它的 Thread.currentThread 作为 Key 存入，Value 是泛型
依照当前线程（currentThread），取的 Value