关于Handler你不知道的事

原创 于 2024-07-31 11:14:38 发布 · 873 阅读 · 10 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#android #java #安卓 #架构 #kotlin

提到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中的信息时，就需要使用变量对这些信息进行存储。

在这里插入图片描述

【Android面试八股文】1. 你说一说Handler机制吧 2. 你知道Handler的同步屏障吗？ 3. Looper一直在循环，会造成阻塞吗？为什么？
字节卷动
06-13 887
开启同步屏障的第一步需要发送一个特殊消息作为屏障消息，当消息队列检测到了这种消息后，就会从这个消息开始，遍历后续的消息只处理其中被标记为“异步”的消息一旦Looper在处理消息时遇到屏障消息，那么就不再处理普通消息，而仅仅处理异步消息。所以叫“同步屏障”。相当于给一部分消息开设了"VIP”优先通道。当使用完同步屏障后我们还注意移除屏障。不再使用屏障后，需要撤销屏障，不然就再也执行不到普通消息了。
Android之Handler、Message、MessageQueue、Looper详解
是阿超
12-06 3324
Android之Handler、Message、MessageQueue、Looper详解
android——Handler的封装（添加软引用）、handle不造成内存泄漏的示例、new匿名实例是否会造成内存泄漏或崩溃
wy313622821的博客
03-23 3251
it1、弱引用（如上）2、在ondestroy里面调用handler.removeCallbacksAndMessages(null);结束！！！！
Handler详解
weixin_42907566的博客
05-27 648
一.什么是Handler Handler是Android机制的一个上层接口,Handler通过发送和处理Message和Runnable对象来关联相对应线程的MessageQueue。 1.可以让对应的Message和Runnable在未来的某个时间点进行相应处理 2.让想要处理的耗时操作放在子线程。让更新UI的操作放在主线程 二.Handler使用方法 1.post(runnable)和send...
Handler机制
似霰的博客
06-18 3189
Handler机制
（一）Handler
JT的专栏
01-27 1619
  面试被拒了两次表示很伤心。。。自己基础都忘光了 第一次遇到的一面试官大大还是很好的，他和我说即使搬砖也要搬地比别人好，推荐我多看看博客，自己平常时间多研究研究新技术。 工作三年，不常用的基础知识几乎忘光了，从基础开始吧。   -------------------------------------------------开始啦----------------------------...
关于Handler同步屏障你可能不知道的问题
一只修仙的猿
03-17 557
前言 很高兴遇见你 ~ 关于handler的内容，基本每个android开发者都掌握了，网络中的优秀博客也非常多，我之前也写过一篇文章，读者感兴趣可以去看看：传送门。 这篇文章主要讲Handler中的同步屏障问题，这也是面试的热门问题。很多读者觉得这一块的知识很偏，实战中并没有什么用处，仅仅用来面试，包括笔者。我在Handler机制一文中写到：其实同步屏障对于我们的日常使用的话其实是没有多大用处。因为设置同步屏障和创建异步Handler的方法都是标志为hide，说明谷歌不想要我们去使用他。 笔者在前段时间面
Handler之消息屏障你应该知道的
天亮了的博客
11-06 5145
前言 由于Handler消息机制的同步屏障问题使用的场景不多，即使不了解可能也不会影响正常开发，因此往往容易被忽视，笔者也是自认比较熟悉Handler的消息机制，在之前同步屏障也算盲区，要想更全面的掌握Handler消息机制，同步屏障就不应该缺席。本文将从同步屏障的插入、删除、使用场景等角度分析同步屏障的工作原理 消息的分类 Message分为3中：普通消息（同步消息）、屏障消息（同步屏障）和异步消息。我们通常使用的都是普通消息，而屏障消息就是在消息队列中插入一个屏障，在屏障之后的所有普通消息都会被挡着，
详解Android中Handler的使用方法
01-04
在Android开发中，我们经常会遇到这样一种情况：在UI界面上进行某项操作后要执行一段很耗时的代码，比如我们在界面上点击了一个”下载“按钮，那么我们需要执行网络请求，这是一个耗时操作，因为不知道什么时候才能...
Handler详解（一）
weixin_43771664的博客
05-04 143
https://www.imooc.com/article/25134?block_id=tuijian_wz
Handler的使用（二）
ＬＯ／QI
02-03 1240
一、Handler与线程     Handler在默认情况下，实际上它和调用它的Activity处于同一个线程。     例如在Handler的使用（一）示例1当中，虽然声明了线程对象，但是在实际调用当中它并没有调用线程的start()方法，而是直接调用当前线程的run()方法。     示例1：在Activity中创建Handler和线程对象，并且在Activity的onCreate方法中
Handler 详解
Linroid的博客
06-22 6869
这个详解基本小结了Handler的使用和相关的知识，在了解这些知识前，我们先来看看这些问题.Handler 是什么？ 子线程更新UI有几种典型方式，这些方式本质上是什么样的？ 子线程真的不能更新UI吗？ HandlerThread是什么？ 主线程和子线程之间如何相互通信？ 好了，如果上面的问题，你能对答如流，并且深知其中的原理那么没有必要继续看下去了，反之，就该好好补补了(^o^)/~。Handle
Handler详解（最容易看懂，最容易理解）
知道的越多，不知道的越多。
02-06 2703
好吧好吧，今天去面试的时候，一个熊二般的面试官问我handler的机制，以及和Looper的关系，以及更新UI有哪些方式。可是我是小白啊，所以不知道，所以就不可能通过面试，不过今年工作可真不好找。回来后又是把书籍，又是看视频，最终还是打算写成自己的博客。希望帮助到其他的小白。 下面我们通过六大模块来了解下handler相关内容（有错误帮忙点出来，谢谢大家。我的理解还很片面和浅薄！） 一、什么是ha...
Handler的用法
Y_C_C的博客
06-07 4186
handler和handler的运行机制 Looper MessageQueue Handler是Android SDK中处理异步消息的核心类，让子线程通过与UI通信来刷新UI。子线程完成工作后通过handler发消息到massage queue，然后让looper从message queue传送消息给主线程。 handler通过接口和继承来实现 运行机制 1.创建一个handler对...
Handler学习（一）- 使用
kk的博客
07-23 362
handler使用： 1）若在Activity主线程中直接用handler - handler和looper在主线程 handler和looper均在主线程，这里可以不需要自己调looper,因为activity的ActivityThread中已经创建并调了loop，而且由于handler一般是用来更新主线程UI的，所以需要保证消息分发来自同一个线程，否则界面更新处理来自多个looper发送的消息会出现布局混乱，而加锁等线程同步会让更新变的更慢还可能出现死锁，得不偿失。 ActivityTh.
上面不使用handler，使用kotlin协程实现
最新发布
04-10
<think>好的，用户想用Kotlin协程替代Handler实现异步任务。首先，我需要回顾一下Handler的传统用法，通常是在子线程执行耗时任务，然后通过Handler.post切换到主线程更新UI。而协程可以简化这个过程，避免回调地狱和内存泄漏问题。 接下来，我需要根据提供的引用内容来整理步骤。引用[1]提到协程可以替代Handler处理线程间通信，引用[2]指出协程底层还是使用Handler的post方法切换回主线程，这说明协程在切换线程时依然依赖Handler，但封装得更好，用户无需直接操作。引用[3]和[4]比较了launch和async的区别，用户需要知道在不需要返回值时使用launch，需要结果时用async。引用[5]提到了Dispatchers，这涉及到协程的线程调度，比如Dispatchers.Main用于主线程，Dispatchers.IO用于子线程。 用户可能需要具体的步骤：如何启动协程，切换线程，处理异常等。需要分步骤说明，比如添加依赖、使用CoroutineScope、切换调度器。同时，要比较协程和Handler的优势，比如代码简洁、自动生命周期管理等。 还要考虑用户可能的疑问，比如协程的作用域管理，防止内存泄漏，以及如何处理取消操作。需要引用相关的内容，比如CoroutineScope和Job的使用。可能还要提到在Android中常用的viewModelScope或lifecycleScope，这些可以自动绑定生命周期，避免泄漏。 最后，生成相关问题，比如性能分析、优化方法、应用场景等，帮助用户深入理解。确保回答结构清晰，步骤明确，引用正确，比如切换线程的部分引用[2]，launch和async的区别引用[3]和[4]。</think>### 如何用 Kotlin 协程替代 Handler 实现异步任务 #### 1. **协程的基本原理** Kotlin 协程通过 `CoroutineScope` 和 `Dispatchers` 实现线程切换。与 Handler 的 `post` 方法类似，协程底层切换回主线程时仍通过 `Handler.post()` 实现[^2]，但语法更简洁且天然支持生命周期管理。 #### 2. **实现步骤** **步骤 1：添加协程依赖** 在项目的 `build.gradle` 中添加： ```kotlin implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.6.4" ``` **步骤 2：启动协程** - **使用 `launch` 执行无返回值的异步任务** 适用于不需要返回结果的操作（如文件操作、UI更新）： ```kotlin CoroutineScope(Dispatchers.IO).launch { // 子线程执行耗时任务（如网络请求） val result = fetchData() // 切换回主线程更新 UI withContext(Dispatchers.Main) { textView.text = result // 引用[2] } } ``` - **使用 `async` 执行有返回值的异步任务** 适用于需要获取结果的场景（如数据库查询）： ```kotlin val deferredResult = CoroutineScope(Dispatchers.IO).async { return@async queryDatabase() } // 获取结果时切换线程 deferredResult.await()?.let { data -> withContext(Dispatchers.Main) { showData(data) } } ``` **步骤 3：绑定生命周期（防止内存泄漏）** 在 Android 中推荐使用 `lifecycleScope` 或 `viewModelScope`： ```kotlin // Activity/Fragment 中 lifecycleScope.launch(Dispatchers.IO) { // 自动跟随生命周期取消协程[^5] } ``` #### 3. **协程与 Handler 的对比** | 特性 | Handler | 协程 | |---------------------|-----------------------------|----------------------------------------------------------------------| | **线程切换** | 需手动调用 `post()` | 通过 `Dispatchers.Main/IO/Default` 自动切换[^5] | | **代码复杂度** | 需多层回调 | 使用同步写法实现异步逻辑 | | **生命周期管理** | 易内存泄漏需手动释放 | 通过 `CoroutineScope` 自动取消[^5] | | **返回值处理** | 无法直接获取 | 可通过 `async`+`await` 获取返回值[^3] | #### 4. **实际案例** **网络请求 + 更新 UI** ```kotlin fun loadData() { viewModelScope.launch { try { // 后台线程执行请求 val response = withContext(Dispatchers.IO) { apiService.fetchData() } // 主线程更新 UI _uiState.value = Success(response) } catch (e: Exception) { _uiState.value = Error(e) } } } ``` #### 5. **注意事项** - **异常处理**：使用 `try-catch` 包裹可能出错的代码块 - **取消协程**：通过 `job.cancel()` 手动取消，或依赖 `lifecycleScope` 自动管理 - **避免 GlobalScope**：优先使用绑定生命周期的 Scope（如 `viewModelScope`）[^4] --- ###
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值