把Handler全身摸个遍

2401_84148974

于 2024-04-20 22:03:00 发布

阅读量680

点赞数 24

分类专栏：程序员文章标签： java 开发语言

本文链接：https://blog.csdn.net/2401_84148974/article/details/138013169

版权

程序员专栏收录该内容

143 篇文章 0 订阅

订阅专栏

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));

}

Looper 提供了 Looper.prepare() 方法来创建 Looper ，并且会借助 ThreadLocal 来实现与当前线程的绑定功能。Looper.loop() 则会开始不断尝试从 MessageQueue 中获取 Message , 并分发给对应的 Handler（见【2.3】）。

也就是说 Handler 跟线程的关联是靠 Looper 来实现的。

2.2 Message 的存储与管理

Handler 提供了一些列的方法让我们来发送消息，如 send()系列 post()系列。

不过不管我们调用什么方法，最终都会走到 MessageQueue.enqueueMessage(Message,long) 方法。

以 sendEmptyMessage(int) 方法为例：

//Handler

sendEmptyMessage(int)

-> sendEmptyMessageDelayed(int,int)

-> sendMessageAtTime(Message,long)

-> enqueueMessage(MessageQueue,Message,long)

-> queue.enqueueMessage(Message, long);

到了这里，消息的管理者 MessageQueue 也就露出了水面。

MessageQueue 顾明思议，就是个队列，负责消息的入队出队。

2.3 Message 的分发与处理

了解清楚 Message 的发送与存储管理后，就该揭开分发与处理的面纱了。

前面说到了 Looper.loop() 负责对消息的分发，本章节进行分析。

先来看看所涉及到的方法：

//Looper

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 (;😉 {

// 不断从 MessageQueue 获取消息

Message msg = queue.next(); // might block

//退出 Looper

if (msg == null) {

// No message indicates that the message queue is quitting.

return;

}

//…

try {

msg.target.dispatchMessage(msg);

end = (slowDispatchThresholdMs == 0) ? 0 : SystemClock.uptimeMillis();

} finally {

//…

}

//…

//回收 message, 见【3.5】

msg.recycleUnchecked();

}

loop() 里调用了 MessageQueue.next() :

//MessageQueue

Message next() {

//…

for (;😉 {

//…

nativePollOnce(ptr, nextPollTimeoutMillis);

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) {

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 {

// Got a message.

mBlocked = false;

if (prevMsg != null) {

prevMsg.next = msg.next;

} else {

mMessages = msg.next;

}

msg.next = null;

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;

}

// Run the idle handlers. 关于 IdleHandler 自行了解

//…

}

还调用了 msg.target.dispatchMessage(msg) ，msg.target 就是发送该消息的 Handler，这样就回调到了 Handler 那边去了:

//Handler

public void dispatchMessage(Message msg) {

//msg.callback 是 Runnable ，如果是 post方法则会走这个 if

if (msg.callback != null) {

handleCallback(msg);

} else {

//callback 见【3.4】

if (mCallback != null) {

if (mCallback.handleMessage(msg)) {

return;

}

//回调到 Handler 的 handleMessage 方法

handleMessage(msg);

}

注意：dispatchMessage() 方法针对 Runnable 的方法做了特殊处理，如果是，则会直接执行 Runnable.run() 。

分析：Looper.loop() 是个死循环，会不断调用 MessageQueue.next() 获取 Message ，并调用 msg.target.dispatchMessage(msg) 回到了 Handler 来分发消息，以此来完成消息的回调。

注意：loop()方法并不会卡死主线程，见【6】。

那么线程的切换又是怎么回事呢？

很多人搞不懂这个原理，但是其实非常简单，我们将所涉及的方法调用栈画出来，如下：

Thread.foo(){

Looper.loop()

-> MessageQueue.next()

-> Message.target.dispatchMessage()

-> Handler.handleMessage()

}

显而易见，Handler.handleMessage() 所在的线程最终由调用 Looper.loop() 的线程所决定。

平时我们用的时候从异步线程发送消息到 Handler，这个 Handler 的 handleMessage() 方法是在主线程调用的，所以消息就从异步线程切换到了主线程。

2.3 图解原理

文字版的原理解析到这里就结束了，如果你看到这里还是没有懂，没关系，我特意给你们准备了些图，配合着前面几个章节，再多看几遍，一定可以吃透。

图片来源见【6】

2.4 小结

Handler 的背后有着 Looper 以及 MessageQueue 的协助，三者通力合作，分工明确。

尝试小结一下它们的职责，如下：

Looper ：负责关联线程以及消息的分发在该线程下**从 MessageQueue 获取 Message，分发给 Handler ；
MessageQueue ：是个队列，负责消息的存储与管理，负责管理由 Handler 发送过来的 Message ；
Handler : 负责发送并处理消息，面向开发者，提供 API，并隐藏背后实现的细节。

对【2】章节提出的问题用一句话总结：

Handler 发送的消息由 MessageQueue 存储管理，并由 Loopler 负责回调消息到 handleMessage()。

线程的转换由 Looper 完成，handleMessage() 所在线程由 Looper.loop() 调用者所在线程决定。

3. Handler 的延伸

Handler 虽然简单易用，但是要用好它还是需要注意一点，另外 Handler相关还有些鲜为人知的知识技巧，比如 IdleHandler。

由于 Handler 的特性，它在 Android 里的应用非常广泛，比如： AsyncTask、HandlerThread、Messenger、IdleHandler 和 IntentService 等等。

这些我会讲解一些，我没讲到的可以自行搜索相关内容进行了解。

3.1 Handler 引起的内存泄露原因以及最佳解决方案

Handler 允许我们发送延时消息，如果在延时期间用户关闭了 Activity，那么该 Activity 会泄露。

这个泄露是因为 Message 会持有 Handler，而又因为 Java 的特性，内部类会持有外部类，使得 Activity 会被 Handler 持有，这样最终就导致 Activity 泄露。

解决该问题的最有效的方法是：将 Handler 定义成静态的内部类，在内部持有 Activity 的弱引用，并及时移除所有消息。

示例代码如下：

private static class SafeHandler extends Handler {

private WeakReference ref;

public SafeHandler(HandlerActivity activity) {

this.ref = new WeakReference(activity);

}

@Override

public void handleMessage(final Message msg) {

HandlerActivity activity = ref.get();

if (activity != null) {

activity.handleMessage(msg);

}

并且再在 Activity.onDestroy() 前移除消息，加一层保障：

@Override

protected void onDestroy() {

safeHandler.removeCallbacksAndMessages(null);

super.onDestroy();

}

这样双重保障，就能完全避免内存泄露了。

注意：单纯的在 onDestroy 移除消息并不保险，因为 onDestroy 并不一定执行。

3.2 为什么我们能在主线程直接使用 Handler，而不需要创建 Looper ？

前面我们提到了每个Handler 的线程都有一个 Looper ，主线程当然也不例外，但是我们不曾准备过主线程的 Looper 而可以直接使用，这是为何？

注意：通常我们认为 ActivityThread 就是主线程。事实上它并不是一个线程，而是主线程操作的管理者，所以吧，我觉得把 ActivityThread 认为就是主线程无可厚非，另外主线程也可以说成 UI 线程。

在 ActivityThread.main() 方法中有如下代码：

//android.app.ActivityThread

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.prepareMainLooper(); 代码如下：

/**

Initialize the current thread as a looper, marking it as an
application’s main looper. The main looper for your application
is created by the Android environment, so you should never need
to call this function yourself. See also: {@link #prepare()}

public static void prepareMainLooper() {

prepare(false);

synchronized (Looper.class) {

if (sMainLooper != null) {

throw new IllegalStateException(“The main Looper has already been prepared.”);

}

sMainLooper = myLooper();

}

可以看到在 ActivityThread 里调用了 Looper.prepareMainLooper() 方法创建了主线程的 Looper ,并且调用了 loop() 方法，所以我们就可以直接使用 Handler 了。

注意：Looper.loop() 是个死循环，后面的代码正常情况不会执行。

3.3 主线程的 Looper 不允许退出

如果你尝试退出 Looper ，你会得到以下错误信息：

Caused by: java.lang.IllegalStateException: Main thread not allowed to quit.

at android.os.MessageQueue.quit(MessageQueue.java:415)

at android.os.Looper.quit(Looper.java:240)

why? 其实原因很简单，主线程不允许退出，退出就意味 APP 要挂。

3.4 Handler 里藏着的 Callback 能干什么？

在 Handler 的构造方法中有几个要求传入 Callback ，那它是什么，又能做什么呢？

来看看 Handler.dispatchMessage(msg) 方法：

public void dispatchMessage(Message msg) {

//这里的 callback 是 Runnable

if (msg.callback != null) {

handleCallback(msg);

} else {

//如果 callback 处理了该 msg 并且返回 true，就不会再回调 handleMessage

if (mCallback != null) {

if (mCallback.handleMessage(msg)) {

return;

}

handleMessage(msg);

}

可以看到 Handler.Callback 有优先处理消息的权利 ，当一条消息被 Callback 处理并拦截（返回 true），那么 Handler 的 handleMessage(msg) 方法就不会被调用了；如果 Callback 处理了消息，但是并没有拦截，那么就意味着一个消息可以同时被 Callback 以及 Handler 处理。

这个就很有意思了，这有什么作用呢？

我们可以利用 Callback 这个拦截机制来拦截 Handler 的消息！

场景：Hook ActivityThread.mH ，在 ActivityThread 中有个成员变量 mH ，它是个 Handler，又是个极其重要的类，几乎所有的插件化框架都使用了这个方法。