关于Handler你不知道的事

于 2024-07-31 11:14:38 发布
阅读量797 收藏 10
点赞数 33
CC 4.0 BY-SA版权
分类专栏： Android点滴 文章标签： android java 安卓 架构 kotlin
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/MC_hust/article/details/140817784

提到Handler，我们都会想到可以用来在子线程给UI线程发送消息，常用来子线程刷新UI。
而往深了问，你一定还知道Handler会绑定到一个Looper，而每个Looper会和一个MessageQ关联，从而达到向指定线程发送消息的功能。除此之外，还了解多少？
提到MessageQueue，就不得不聊到Android的消息处理机制。

Handler消息处理机制

Android的消息机制，涉及到Handler、Looper、Message和MessageQueue。

  • Handler是用于处理Message的对象。它通常与一个特定的线程(通常是主线程)关联。通过Handler开发者可以将Message发送到与其关联的线程的消息队列中,以便在那个线程中执行处理。
  • Message是一个包含要传递的数据和指令的的对象。当需要在不同线程之间传递数据或执行行任务时,通常会创建一个Message并将其发送给Handler。
  • Looper是一个用于管理线程的消息队列别的对象。每个线程都可以有一个Looper，它会在线程上创建一个消息队列，允许该线程接收并处理Message。主线程通常已经具有一个默认的Looper，而其他线程需要显式创建一个Looper。
  • MessageQueue即是消息队列。是一个FIFO(先进先出)队列,用于存储待处理的Message。每个Looper都有一个关联的MessageQueue，Handler将Message发送到这个队列中,然后由Looper依次处理队列中的Message。

简易的消息处理机制流程图

DeveloperLooperHandlerMessageQueueJNILooper@prepare循环取消息Handler@dispatchMessageLooper@loopMessage@nextnativePollOncenative处理MessageQ及LooperMessage@CallbackHandlerHandlerMessage@recycerUncheckedMessage@obtainHandler@enqueueMessageMessageQueue@enqueueMessagenativeWakeDeveloperLooperHandlerMessageQueueJNI

MessageQueue

从上面的描述，我们可以MessageQueue会按照一定的规则取出要执行的Message，当消息执行完之后Message就会被回收。

那么下面我们就通过代码来验证几种情况：

  • Message#Obtain创建消息的消息和直接New Message的方法创建消息，是否都会被回收
  • 如果消息对象被持有，是否消息也会被回收
  • 如果接受消息在主线程，那么在View#post方法执行后，消息是否会被回收
  • 如果接收消息在主线程，那么当切换到其他线程执行任务后，消息是否会被回收
  • 如果接受消息在主线程，通过Kotlin Coroutine执行任务在 Dispatchers.Main或 Dispatchers.Default后，消息是否会被回收

通过Message#Obtain创建消息并发送

 Message.obtain(). also { it.what = 1  mObtainMsg = it mHandler.sendMessage(it) }

通过直接New的方法创建消息并发送

Message().also {
it.what = 2
    mHandler.sendMessage(it)
}

发送消息后打印消息信息

class MyHandler(private val actRef: WeakReference<TestMessageActivity>) :
    Handler(Looper.getMainLooper()) {
    override fun handleMessage(msg: Message) {
        super.handleMessage(msg)
        val act = actRef.get() ?: return
        Log.d(TAG, "msg:$msg}")
        Log.d(TAG, "mObtainMsg:${act.mObtainMsg}}")

        act.mSWThread.post {
Log.d(TAG, "msg--post:$msg}")
            Log.d(TAG, "mObtainMsg--post:${act.mObtainMsg}}")
        }
if (act.mSWThread.isChecked) {//是否开启了子线程
            Thread {
Log.d(TAG, "thread--msg:$msg}")
                Log.d(TAG, "thread--mObtainMsg:${act.mObtainMsg}}")
                Thread.sleep(3000L)
                Log.d(TAG, "threadAfter--msg:$msg}")
                Log.d(TAG, "threadAfter--mObtainMsg:${act.mObtainMsg}}")
            } .start()
        }
        if (act.mSWCoroutine.isChecked) {//是否开启协程
            GlobalScope.launch(Dispatchers.Main) {
Log.d(TAG, "launchMain----msg:$msg}")
                Log.d(TAG, "launchMain--mObtainMsg:${act.mObtainMsg}}")
            }
GlobalScope.launch {
Log.d(TAG, "launch--msg:$msg}")
                Log.d(TAG, "launch--mObtainMsg:${act.mObtainMsg}}")
            }
}


    }
}

Obtain创建消息发送消息，收到的日志结果

2024-03-22 16:32:04.780 21621-21621/com.lotus.duode.myapplication D/TestMessageActivity: msg:{ when=-1ms what=1 target=com.lotus.duode.myapplication.TestMessageActivity$MyHandler }}
2024-03-22 16:32:04.780 21621-21621/com.lotus.duode.myapplication D/TestMessageActivity: mObtainMsg:{ when=-1ms what=1 target=com.lotus.duode.myapplication.TestMessageActivity$MyHandler }}
2024-03-22 16:32:04.781 21621-22106/com.lotus.duode.myapplication D/TestMessageActivity: thread--msg:{ when=-2ms what=1 target=com.lotus.duode.myapplication.TestMessageActivity$MyHandler }}
2024-03-22 16:32:04.781 21621-22106/com.lotus.duode.myapplication D/TestMessageActivity: thread--mObtainMsg:{ when=-2ms what=1 target=com.lotus.duode.myapplication.TestMessageActivity$MyHandler }}
2024-03-22 16:32:04.803 21621-22108/com.lotus.duode.myapplication D/TestMessageActivity: launch--msg:{ when=-19ms callback=android.view.Choreographer$FrameDisplayEventReceiver target=android.view.Choreographer$FrameHandler }}
2024-03-22 16:32:04.803 21621-22108/com.lotus.duode.myapplication D/TestMessageActivity: launch--mObtainMsg:{ when=-19ms callback=android.view.Choreographer$FrameDisplayEventReceiver target=android.view.Choreographer$FrameHandler }}
2024-03-22 16:32:04.806 21621-21621/com.lotus.duode.myapplication D/TestMessageActivity: msg--post:{ when=-2d2h37m50s923ms barrier=0 }}
2024-03-22 16:32:04.806 21621-21621/com.lotus.duode.myapplication D/TestMessageActivity: mObtainMsg--post:{ when=-2d2h37m50s923ms barrier=0 }}
2024-03-22 16:32:04.806 21621-21621/com.lotus.duode.myapplication D/TestMessageActivity: launchMain----msg:{ when=-2d2h37m50s923ms barrier=0 }}
2024-03-22 16:32:04.806 21621-21621/com.lotus.duode.myapplication D/TestMessageActivity: launchMain--mObtainMsg:{ when=-2d2h37m50s923ms barrier=0 }}
2024-03-22 16:32:07.782 21621-22106/com.lotus.duode.myapplication D/TestMessageActivity: threadAfter--msg:{ when=-2d2h37m53s899ms barrier=0 }}
2024-03-22 16:32:07.782 21621-22106/com.lotus.duode.myapplication D/TestMessageActivity: threadAfter--mObtainMsg:{ when=-2d2h37m53s899ms barrier=0 }}

New Message创建消息发送消息，收到的日志结果

2024-03-22 16:32:27.427 21621-21621/com.lotus.duode.myapplication D/TestMessageActivity: msg:{ when=-9ms what=2 target=com.lotus.duode.myapplication.TestMessageActivity$MyHandler }}
2024-03-22 16:32:27.428 21621-21621/com.lotus.duode.myapplication D/TestMessageActivity: mObtainMsg:{ when=-2ms callback=android.view.Choreographer$FrameDisplayEventReceiver target=android.view.Choreographer$FrameHandler }}
2024-03-22 16:32:27.428 21621-22116/com.lotus.duode.myapplication D/TestMessageActivity: thread--msg:{ when=-10ms what=2 target=com.lotus.duode.myapplication.TestMessageActivity$MyHandler }}
2024-03-22 16:32:27.428 21621-22116/com.lotus.duode.myapplication D/TestMessageActivity: thread--mObtainMsg:{ when=-3ms callback=android.view.Choreographer$FrameDisplayEventReceiver target=android.view.Choreographer$FrameHandler }}
2024-03-22 16:32:27.428 21621-22108/com.lotus.duode.myapplication D/TestMessageActivity: launch--msg:{ when=-2d2h38m13s545ms barrier=0 }}
2024-03-22 16:32:27.428 21621-22108/com.lotus.duode.myapplication D/TestMessageActivity: launch--mObtainMsg:{ when=-3ms callback=android.view.Choreographer$FrameDisplayEventReceiver target=android.view.Choreographer$FrameHandler }}
2024-03-22 16:32:27.430 21621-21621/com.lotus.duode.myapplication D/TestMessageActivity: msg--post:{ when=-1ms callback=android.view.Choreographer$$ExternalSyntheticLambda0 target=android.view.Choreographer$FrameHandler }}
2024-03-22 16:32:27.430 21621-21621/com.lotus.duode.myapplication D/TestMessageActivity: mObtainMsg--post:{ when=-2d2h38m13s547ms barrier=0 }}
2024-03-22 16:32:27.430 21621-21621/com.lotus.duode.myapplication D/TestMessageActivity: launchMain----msg:{ when=-2ms callback=android.view.Choreographer$$ExternalSyntheticLambda0 target=android.view.Choreographer$FrameHandler }}
2024-03-22 16:32:27.430 21621-21621/com.lotus.duode.myapplication D/TestMessageActivity: launchMain--mObtainMsg:{ when=-2d2h38m13s547ms barrier=0 }}
2024-03-22 16:32:30.429 21621-22116/com.lotus.duode.myapplication D/TestMessageActivity: threadAfter--msg:{ when=-2d2h38m16s546ms barrier=0 }}
2024-03-22 16:32:30.429 21621-22116/com.lotus.duode.myapplication D/TestMessageActivity: threadAfter--mObtainMsg:{ when=-2d2h38m16s546ms barrier=0 }}

结论

通过Handler#handleMessage接收的消息，在消息执行完成之后。如果后续有新的消息需要被使用，那么系统会通过Message#obtain创建消息时，就会从Message#sPool 中进行复用。

请添加图片描述

而消息的回收是在DispatchMessage完成之后。

在这里插入图片描述

因此如果我们需要持久化使用Message中的信息时，就需要使用变量对这些信息进行存储。

在这里插入图片描述

Handler详解（最容易看懂，最容易理解）
知道的越多，不知道的越多。
02-06 2591
好吧好吧，今天去面试的时候，一个熊二般的面试官问我handler的机制，以及和Looper的关系，以及更新UI有哪些方式。可是我是小白啊，所以不知道，所以就不可能通过面试，不过今年工作可真不好找。回来后又是把书籍，又是看视频，最终还是打算写成自己的博客。希望帮助到其他的小白。 下面我们通过六大模块来了解下handler相关内容（有错误帮忙点出来，谢谢大家。我的理解还很片面和浅薄！） 一、什么是ha...
【Android面试八股文】1. 你说一说Handler机制吧 2. 你知道Handler的同步屏障吗？ 3. Looper一直在循环，会造成阻塞吗？为什么？
字节卷动
06-13 712
开启同步屏障的第一步需要发送一个特殊消息作为屏障消息，当消息队列检测到了这种消息后，就会从这个消息开始，遍历后续的消息只处理其中被标记为“异步”的消息一旦Looper在处理消息时遇到屏障消息，那么就不再处理普通消息，而仅仅处理异步消息。所以叫“同步屏障”。相当于给一部分消息开设了"VIP”优先通道。当使用完同步屏障后我们还注意移除屏障。不再使用屏障后，需要撤销屏障，不然就再也执行不到普通消息了。
（一）Handler
JT的专栏
01-27 1513
  面试被拒了两次表示很伤心。。。自己基础都忘光了 第一次遇到的一面试官大大还是很好的，他和我说即使搬砖也要搬地比别人好，推荐我多看看博客，自己平常时间多研究研究新技术。 工作三年，不常用的基础知识几乎忘光了，从基础开始吧。   -------------------------------------------------开始啦----------------------------...
Handler详解
whyalwaysmea
03-11 2957
Handler、Message、异步消息处理
Handler详解（一）
weixin_43771664的博客
05-04 133
https://www.imooc.com/article/25134?block_id=tuijian_wz
Handler的使用（二）
ＬＯ／QI
02-03 1206
一、Handler与线程     Handler在默认情况下，实际上它和调用它的Activity处于同一个线程。     例如在Handler的使用（一）示例1当中，虽然声明了线程对象，但是在实际调用当中它并没有调用线程的start()方法，而是直接调用当前线程的run()方法。     示例1：在Activity中创建Handler和线程对象，并且在Activity的onCreate方法中
关于Handler同步屏障你可能不知道的问题
一只修仙的猿
03-17 527
前言 很高兴遇见你 ~ 关于handler的内容，基本每个android开发者都掌握了，网络中的优秀博客也非常多，我之前也写过一篇文章，读者感兴趣可以去看看：传送门。 这篇文章主要讲Handler中的同步屏障问题，这也是面试的热门问题。很多读者觉得这一块的知识很偏，实战中并没有什么用处，仅仅用来面试，包括笔者。我在Handler机制一文中写到：其实同步屏障对于我们的日常使用的话其实是没有多大用处。因为设置同步屏障和创建异步Handler的方法都是标志为hide，说明谷歌不想要我们去使用他。 笔者在前段时间面
Handler之消息屏障你应该知道的
天亮了的博客
11-06 5091
前言 由于Handler消息机制的同步屏障问题使用的场景不多，即使不了解可能也不会影响正常开发，因此往往容易被忽视，笔者也是自认比较熟悉Handler的消息机制，在之前同步屏障也算盲区，要想更全面的掌握Handler消息机制，同步屏障就不应该缺席。本文将从同步屏障的插入、删除、使用场景等角度分析同步屏障的工作原理 消息的分类 Message分为3中：普通消息（同步消息）、屏障消息（同步屏障）和异步消息。我们通常使用的都是普通消息，而屏障消息就是在消息队列中插入一个屏障，在屏障之后的所有普通消息都会被挡着，
详解Android中Handler的使用方法
01-04
在Android开发中，我们经常会遇到这样一种情况：在UI界面上进行某项操作后要执行一段很耗时的代码，比如我们在界面上点击了一个”下载“按钮，那么我们需要执行网络请求，这是一个耗时操作，因为不知道什么时候才能...
Android之Handler、Message、MessageQueue、Looper详解
是阿超
12-06 3205
Android之Handler、Message、MessageQueue、Looper详解
Handler 详解
Linroid的博客
06-22 6830
这个详解基本小结了Handler的使用和相关的知识，在了解这些知识前，我们先来看看这些问题.Handler 是什么？ 子线程更新UI有几种典型方式，这些方式本质上是什么样的？ 子线程真的不能更新UI吗？ HandlerThread是什么？ 主线程和子线程之间如何相互通信？ 好了，如果上面的问题，你能对答如流，并且深知其中的原理那么没有必要继续看下去了，反之，就该好好补补了(^o^)/~。Handle
Handler的用法
Y_C_C的博客
06-07 4162
handler和handler的运行机制 Looper MessageQueue Handler是Android SDK中处理异步消息的核心类，让子线程通过与UI通信来刷新UI。子线程完成工作后通过handler发消息到massage queue，然后让looper从message queue传送消息给主线程。 handler通过接口和继承来实现 运行机制 1.创建一个handler对...
Handler学习（一）- 使用
kk的博客
07-23 337
handler使用： 1）若在Activity主线程中直接用handler - handler和looper在主线程 handler和looper均在主线程，这里可以不需要自己调looper,因为activity的ActivityThread中已经创建并调了loop，而且由于handler一般是用来更新主线程UI的，所以需要保证消息分发来自同一个线程，否则界面更新处理来自多个looper发送的消息会出现布局混乱，而加锁等线程同步会让更新变的更慢还可能出现死锁，得不偿失。 ActivityTh.
Handler()的常见使用
baidu_38317922的博客
10-20 99
Handler()的常见使用
Handler机制（一）——Handler运行流程分析
一切皆是定数的博客
10-07 2844
Handler运行机制
Handler 详细解释
w1355485804的博客
03-08 502
1.什么是Handler？ handler是Android给我们提供用来更新UI的一套机制，也是一套消息处理机制，我们可以发消息，也可以通过它处理消息。 也就是最普通的步骤： 创建handler对象 发送消息 接收消息 那我们能不能不用handler呢？ 答案是 肯定不行的，因为在安卓设计的时候，就封装了消息的创建，传递，处理，只有遵循才能更新UI，不然会报异常！ 2，什么是L...
android handler消息机制
最新发布
03-08
<think>好的，用户想了解Android中的Handler消息处理机制，包括原理和使用教程。我需要根据提供的三个引用资料来整理回答，确保内容准确，并且符合用户的要求，比如使用正确的中文、LaTeX格式，生成相关问题等等。 首先，我需要回顾一下Handler的基本作用。根据引用[2]，Handler的主要作用是将任务切换到其所在的线程执行，尤其是在子线程操作后更新UI，因为Android不允许子线程直接访问UI。所以，Handler常用于线程间通信，特别是子线程到主线程的消息传递。 接下来，关于原理部分，引用[1]和[3]提到消息机制的核心包括Handler、MessageQueue、Looper和Message。需要详细解释这四个组件的关系。Looper负责循环取出消息，MessageQueue存储消息队列，Handler发送和处理消息。可能还需要提到Looper.prepare()和Looper.loop()的初始化过程，以及主线程中已经创建好的Looper。 在消息传递流程方面，用户可能想知道消息是如何从发送到处理的。例如，Handler发送消息到MessageQueue，Looper不断取出消息并回调给Handler的handleMessage方法。这里需要分步骤说明，确保流程清晰。 使用教程部分，需要给出创建Handler、发送消息和处理消息的具体代码示例。比如在主线程创建Handler，在子线程使用post或sendMessage方法发送消息，然后在handleMessage中更新UI。同时要注意代码的正确性，比如在子线程中创建Handler需要先调用Looper.prepare()，但主线程已经默认有了Looper，所以不需要。 然后，根据用户的要求生成相关问题。可能需要包括Handler的其他用途、避免内存泄漏的方法、主线程为何不需要手动创建Looper等。这些问题需要覆盖原理、使用注意事项和常见问题。 最后，检查是否符合所有系统级指令，比如行内数学表达式是否用$...$，独立公式是否用$$...$$，不过当前内容可能不涉及数学公式，但需要确认是否有其他格式要求。确保LaTeX语法正确，用中文回答，结构清晰，分步骤说明，并在引用的地方添加引用标识。 可能需要注意引用资料的来源是否准确，特别是引用的三个资料都是关于Handler的，需要正确对应到各个部分。例如，引用[3]中的handleCallback方法可能涉及消息处理的内部机制，可以提到Message的callback运行。 同时，用户可能存在的深层需求是了解如何正确使用Handler避免ANR或内存泄漏，或者理解其背后的设计模式，比如消息循环模型。在回答中可以适当提及这些点，但根据提供的引用资料，可能主要依据现有内容。 现在需要整理这些思路，按照用户提供的结构来组织回答，确保每个部分都有对应的引用支持，并且问题部分相关且合理。</think>### Android Handler消息处理机制详解 #### 一、核心组件与原理 Android的Handler消息机制基于四个核心组件： 1. **Handler**：负责发送消息到`MessageQueue`，并处理`Looper`分发的消息。 2. **MessageQueue**：以队列形式存储消息（单链表实现）[^1][^3]。 3. **Looper**：循环从`MessageQueue`中取出消息并分发给对应的`Handler`[^2]。 4. **Message**：封装消息内容，包含目标`Handler`和回调方法等信息。 **运行流程**： 1. **Looper初始化**：主线程默认已初始化`Looper`，子线程需手动调用`Looper.prepare()`和`Looper.loop()`[^2]。 2. **消息发送**：通过`Handler.sendMessage()`或`post(Runnable)`将消息加入队列。 3. **消息循环**：`Looper`通过`MessageQueue.next()`轮询取出消息，通过`msg.target.dispatchMessage(msg)`回调处理。 4. **消息处理**：根据消息类型执行： - 若`Message`设置了`callback`（如`Runnable`），直接执行`message.callback.run()`。 - 否则，调用`Handler.handleMessage()`实现业务逻辑。 #### 二、使用教程 **1. 主线程创建Handler（更新UI）** ```java // 主线程中创建Handler Handler handler = new Handler(Looper.getMainLooper()) { @Override public void handleMessage(Message msg) { super.handleMessage(msg); if (msg.what == 1) { textView.setText("更新UI成功"); } } }; // 子线程发送消息 new Thread(() -> { Message msg = handler.obtainMessage(1); handler.sendMessage(msg); }).start(); ``` **2. 子线程创建Handler（需初始化Looper）** ```java new Thread(() -> { Looper.prepare(); // 初始化Looper Handler subHandler = new Handler() { @Override public void handleMessage(Message msg) { // 处理子线程消息 } }; Looper.loop(); // 启动消息循环 }).start(); ``` **3. 发送消息的两种方式** - **延时消息**：`handler.sendMessageDelayed(msg, 1000)` - **Runnable方式**：`handler.post(() -> { /* 执行代码 */ })` #### 三、关键注意事项 1. **内存泄漏**：若`Handler`持有`Activity`引用，需使用`WeakReference`或`static`修饰[^1]。 2. **主线程限制**：`handleMessage()`默认在主线程执行，避免耗时操作（否则可能引发ANR）[^2]。 3. **Looper生命周期**：子线程使用完需调用`Looper.quit()`释放资源。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值