Handler 知识点梳理：Handler、Looper 以及 Message 三者之间的关系

移不动开发技术

于 2022-08-26 15:48:43 发布

阅读量2k

点赞数 1

分类专栏： Android开发 Android工程师移动开发文章标签： java 开发语言 android 学习程序人生

本文链接： https://blog.csdn.net/m0_62167422/article/details/126544730

版权

Android开发同时被 3 个专栏收录

56 篇文章 12 订阅

订阅专栏

移动开发

49 篇文章 1 订阅

订阅专栏

Android工程师

43 篇文章 0 订阅

订阅专栏

前言

Handler、Looper以及Message之间的关系，概括性来说，Looper负责的是创建一个MessageQueue对象，然后进入到一个无限循环体中不断取出消息，而这些消息都是由一个或者多个Handler进行创建处理

Messagequeue 的数据结构是什么？

基础数据结构中 “先进先出” 的一种数据结构

Handler post 原理

消息是通过 MessageQueen 中的 enqueueMessage()方法加入消息队列中的，并且它在放入中就进行好排序，链表头的延迟时间小，尾部延迟时间最大

Looper.loop()通过 MessageQueue 中的 next()取消息
next()中如果当前链表头部消息是延迟消息，则根据延迟时间进行消息队列会阻塞，不返回给 Looper message，知道时间到了，返回给 message
如果在阻塞中有新的消息插入到链表头部则唤醒线程
Looper 将新消息交给回调给 handler 中的 handleMessage 后，继续调用 MessageQueen的next()方法，如果刚刚的延迟消息还是时间未到，则计算时间继续阻塞

handler.postDelay()的实现是通过MessageQueue中执行时间顺序排列，消息队列阻塞和唤醒的方式结合实现的；如果真的是通过延迟将消息放入到 MessageQueen中，那放入多个延迟消息就要维护多个定时器

Android 消息机制的简介

在 Android 中使用消息机制，我们首先想到的就是 Handler；没错，Handler是 Android 消息机制的上层接口；Handler 的使用过程很简单，通过它可以轻松地将一个任务切换到Handler所在的线程中去执行。通常情况下，Handler的使用场景就是更新UI

在子线程中，进行耗时操作，执行完操作后，发送消息，通知主线程更新 UI；这便是消息机制的典型应用场景。我们通常只会接触到 Handler 和 Message 来完成消息机制，其实内部还有两大助手来共同完成消息传递

消息机制的模型消息机制主要包含： MessageQueue，Handler和Looper这三大部分，以及Message，下面我们一一介绍

Message： 需要传递的消息，可以传递数据；
MessageQueue： 消息队列，但是它的内部实现并不是用的队列，实际上是通过一个单链表的数据结构来维护消息列表，因为单链表在插入和删除上比较有优势。主要功能向消息池投递消息(MessageQueue.enqueueMessage)和取走消息池的消息(MessageQueue.next)；
Handler： 消息辅助类，主要功能向消息池发送各种消息事件 (Handler.sendMessage)和处理相应消息事件(Handler.handleMessage)；
Looper： 不断循环执行(Looper.loop)，从 MessageQueue中读取消息，按分发机制将消息分发给目标处理者

消息机制的架构

消息机制的运行流程： 在子线程执行完耗时操作，当 Handler 发送消息时，将会调用MessageQueue.enqueueMessage，向消息队列中添加消息

当通过Looper.loop 开启循环后，会不断地从线程池中读取消息 ，即调用 MessageQueue.next，然后调用目标 Handler（即发送该消息的 Handler）的 dispatchMessage 方法传递消息，然后返回到 Handler 所在线程，目标 Handler 收到消息，调用 handleMessage方法，接收消息，处理消息

MessageQueue，Handler 和 Looper 三者之间的关系： 每个线程中只能存在一个 Looper，Looper 是保存在 ThreadLocal 中的。主线程（UI 线程）已经创建了一个 Looper，所以在主线程中不需要再创建 Looper，但是在其他线程中需要创建 Looper

每个线程中可以有多个 Handler，即一个Looper 可以处理来自多个 Handler的消息 ；Looper 中维护一个MessageQueue，来维护消息队列，消息队列中的 Message可以来自不同的 Handler

Looper 有一个 MessageQueue 消息队列
MessageQueue 有一组待处理的 Message
Message中记录发送和处理消息的 Handler
Handler中有 Looper 和 MessageQueue

我们可以使用 Handler 发送并处理与一个线程关联的 Message 和 Runnable ；（注意：Runnable 会被封装进一个 Message，所以它本质上还是一个 Message ）每个 Handler 都会跟一个线程绑定，并与该线程的 MessageQueue 关联在一起，从而实现消息的管理以及线程间通信

Handler 的背后有着 Looper 以及 MessageQueue 的协助，三者通力合作，分工明确；尝试小结一下它们的职责，如下：
Looper ： 负责关联线程以及消息的分发在该线程下从 MessageQueue 获取 Message，分发给 Handler ；
MessageQueue ： 是个队列，负责消息的存储与管理，负责管理由 Handler 发送过来的 Message ；
Handler : 负责发送并处理消息，面向开发者，提供 API，并隐藏背后实现的细节
Handler 发送的消息由 MessageQueue 存储管理，并由 Loopler 负责回调消息到 handleMessage()；线程的转换由 Looper 完成，handleMessage() 所在线程由 Looper.loop() 调用者所在线程决定

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

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

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

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

示例代码如下：

private static class SafeHandler extends Handler {
private WeakReference<HandlerActivity> 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() 前移除消息，加一层保障：

@Overrideprotected void onDestroy() {
safeHandler.removeCallbacksAndMessages(null);
super.onDestroy();
}

这样双重保障，就能完全避免内存泄露了。注意：单纯的在 onDestroy 移除消息并不保险，因为 onDestroy 并不一定执行

1. Handler 的背后有 Looper 、 MessageQueue 支撑， Looper 负责消息分发， MessageQueue 负责消息管理；
1. 在创建 Handler 之前一定需要先创建 Looper；
1. Looper 有退出的功能，但是主线程的 Looper 不允许退出；
1. 异步线程的 Looper 需要自己调用 Looper.myLooper().quit(); 退出；
1. Runnable 被封装进了 Message，可以说是一个特殊的 Message；
1. Handler.handleMessage() 所在的线程是 Looper.loop() 方法被调用的线程，也可以说成 Looper所在的线程，并不是创建Handler的线程；
1. 使用内部类的方式使用Handler可能会导致内存泄露，即便在 Activity.onDestroy 里移除延时消息，必须要写成静态内部类