246.性能优化-卡顿优化--性能优化方案-耗时操作过多-耗时操作放入异步

我也念过晚霞

已于 2025-03-31 13:03:27 修改

阅读量849

点赞数 13

分类专栏： Android学习文章标签：性能优化

于 2025-03-31 09:05:27 首次发布

本文链接：https://blog.youkuaiyun.com/2303_79132118/article/details/146798485

版权

Android学习专栏收录该内容

253 篇文章

订阅专栏

────────────────────────────── 【一、耗时操作及其影响】

在Android开发中，应用运行过程中常会涉及一些耗时操作。这些操作通常包括：

网络请求（数据下载、上传等）
磁盘IO（读写文件、数据库操作）
复杂计算任务（数据解析、图像处理）
大量数据处理（如遍历大量数据）
其他阻塞性任务

如果这些操作在主线程（UI线程）中执行，会导致界面卡顿甚至ANR（Application Not Responding），严重影响用户体验。Android系统对主线程执行的任务有严格要求，确保UI能够流畅响应用户输入。当主线程被阻塞时，就会出现卡顿现象。因此，优化耗时操作是性能优化中重要的一环。

例如，如果你在主线程中做一个网络请求，用户在等待过程中界面不会刷新；再比如，复杂的计算或数据库查询如果在UI线程中执行，也会导致按钮点击、动画卡顿等现象。因此将这些任务移出主线程，放入异步线程执行就变得十分必要。

────────────────────────────── 【二、耗时操作的常见场景】

在实际开发中，我们经常会遇到以下几类耗时操作：

网络通信：
使用HttpClient、Retrofit或其他网络框架时，网络请求一般需要等待服务器响应。如果在主线程中请求，会导致UI卡顿，甚至出现ANR。
数据库操作：
操作SQLite数据库或者使用Room数据持久化时，大量的数据插入或查询操作可能会非常耗时。如果这些操作放在主线程中进行，会影响界面响应，降低用户体验。
文件读写：
与磁盘文件相关的读写操作，例如缓存数据、图片加载等，可能比较耗时，尤其是在大文件或大量数据的情况下。
图像处理：
图片解码、缩放、滤镜处理等操作通常需要消耗大量CPU资源，如果放在主线程中进行，会严重影响UI流畅性。
CPU密集型任务：
数据解析、加密解密或复杂算法计算，因为耗时且CPU占用高，通常需要异步执行。

由于这些操作在执行过程中会阻塞主线程，所以必须使用异步机制将其移到子线程中，以确保主线程专注于UI更新与用户交互。

────────────────────────────── 【三、同步与异步的基本概念及对比】

同步 (Synchronous)：
同步操作的基本特点是调用方必须等待耗时操作完成后才能继续执行后续代码。就好比你在餐厅点餐，必须等待菜上桌后你才能开始用餐。如果耗时操作比较久，用户体验就会受到影响。
异步 (Asynchronous)：
异步操作的特点是调用方发出操作请求后，不必等待耗时操作完成，而是继续执行后续代码。耗时操作完成后，会通过回调、消息发布等机制通知调用方。这就类似于你在餐厅订餐后，可以先去洗手间，菜上桌后服务员会通知你，提升了整体体验。

【同步与异步的优劣对比】

同步优点：实现简单、逻辑清晰。
同步缺点：会阻塞主线程，影响UI响应和用户体验。
异步优点：不会阻塞主线程，可以充分利用多核CPU和线程池，将耗时操作放入后台执行，提高响应速度。
异步缺点：编写起来较为复杂，需要设计回调、消息传递或异常处理机制，容易引入线程安全问题。

因此，在面对耗时操作时，通常选择异步方式。

────────────────────────────── 【四、如何将耗时操作放入异步线程：方案与实践】

在Android中常用的异步处理方案有多种，我们主要讨论以下几种常见方式，并结合Kotlin语言进行讲解：

使用Java线程（Thread、Runnable）：
最直接地创建子线程，通过Thread.start()启动任务。
使用HandlerThread与Handler：
HandlerThread是一个具备Looper的子线程，结合Handler，能够实现任务排队执行的目的。
使用AsyncTask（现已废弃）：
早期使用比较多的异步任务方案，虽然简化了操作，但是在复杂场景下不够灵活，而且API有一些限制，随着新方案的出现逐步被淘汰。
使用Kotlin协程：
协程是现代异步编程的推荐方案，通过suspend、launch、async等关键词使异步代码看起来像同步代码，逻辑上更为直观。
使用其他线程池方案：
通过Executors.newFixedThreadPool或CachedThreadPool创建线程池，从而管理并发任务。

在下面几节中，我们将重点介绍Kotlin协程作为异步执行的先进方案，以及如何结合其他方案进行实践。

────────────────────────────── 【五、Kotlin异步编程：协程基础】

Kotlin协程（Coroutines）是目前Android推荐的异步和并发编程模型。其优势包括：

代码结构清晰、可读性高
支持挂起函数，使耗时操作的执行逻辑类似同步代码
简化异常处理、取消操作
提供Dispatcher切换（例如Dispatchers.Main、Dispatchers.IO、Dispatchers.Default），可以方便地将任务分配给UI线程、IO线程等

基本的协程操作流程：

启动协程：
使用GlobalScope.launch或在生命周期作用域中使用lifecycleScope.launch启动一个协程。
切换Dispatcher：
当需要执行IO密集型任务时，可以使用withContext(Dispatchers.IO){ }切换到IO线程；类似地，可以使用Dispatchers.Default处理CPU密集型任务；最终UI更新必须回到Dispatchers.Main。
挂起函数（suspend function）：
使用suspend关键字标记函数为可挂起函数，此函数内部可以调用其他挂起函数。挂起函数可以在不阻塞线程的情况下等待耗时结果。

下面是一个简单示例，展示如何使用协程进行网络请求：

import kotlinx.coroutines.*
import java.net.URL

/*
runBlocking 在 Kotlin 协程中是一个非常重要的函数，用于启动一个新的协程并阻塞当前线程，直到该协程执行完成

withContext 是 Kotlin 协程库中的一个函数，用于在指定的协程上下文中执行代码块
并在执行完成后返回结果。它是一个挂起函数，因此必须在协程作用域或其他挂起函数中调用。
 */
fun main() = runBlocking {
    println("主线程开始：${Thread.currentThread().name}")
    // 启动一个IO任务
    val data = withContext(Dispatchers.IO) {
        // 模拟耗时网络请求
        println("网络请求在线程：${Thread.currentThread().name}")
        URL("https://www.example.com").readText()
    }
    // 回到主线程更新UI
    println("主线程结束：${Thread.currentThread().name}")
    println("获取到的数据长度：${data.length}")
}

在这个例子中，我们用withContext将网络请求任务放入IO线程，等到任务完成后，再将结果返回到主线程。协程的写法使得异步代码逻辑清晰，而无需嵌套回调。

────────────────────────────── 【六、如何将耗时操作放入异步：多种实现方式】

下面分别介绍几种常见的异步实现方式及代码示例。

使用原生Thread实现异步执行
最直观的方法就是：新建线程，并将耗时任务放入新线程中执行。缺点是需要手动处理线程切换和UI更新，代码较为冗长。

import android.os.Bundle
import android.os.Handler
import android.os.Looper
import androidx.appcompat.app.AppCompatActivity

/*
mainHandler.post 是 Android 中用于将一个 Runnable 对象提交到主线程（UI 线程）执行的方法
它的主要目的是在后台线程中执行完任务后，将结果或 UI 更新操作传递到主线程执行，从而避免在后台线程直接操作 UI 界面导致的线程安全问题。
 */
class ThreadExampleActivity : AppCompatActivity() {

    private val mainHandler = Handler(Looper.getMainLooper())

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        // 假设界面布局只有一个TextView用于展示结果
        setContentView(R.layout.activity_thread_example)

        Thread(Runnable {
            // 在子线程中执行耗时操作
            val result = doTimeConsumingOperation()

            // 通过Handler切换回主线程更新UI
            mainHandler.post {
                // 更新UI，例如TextView.setText(result)
            }
        }).start()
    }

    private fun doTimeConsumingOperation(): String {
        // 模拟耗时任务，例如文件读取或长时间计算
        Thread.sleep(3000)
        return "操作完成"
    }
}

使用HandlerThread与Handler
HandlerThread本质上是一个带有Looper的线程，结合Handler可以实现任务队列式处理异步任务。适用于需要连续处理多个耗时任务的场景，可以减少频繁创建线程的开销。

import android.os.Bundle
import android.os.Handler
import android.os.HandlerThread
import android.os.Looper
import androidx.appcompat.app.AppCompatActivity

class HandlerThreadExampleActivity : AppCompatActivity() {

    private lateinit var handlerThread: HandlerThread // 声明一个 HandlerThread 对象，用于在后台执行任务
    private lateinit var backgroundHandler: Handler // 声明一个 Handler 对象，用于将任务提交到 HandlerThread 执行

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_handler_thread_example)

        // 创建HandlerThread并启动
        handlerThread = HandlerThread("BackgroundThread")
        handlerThread.start() // 启动 HandlerThread，开始执行线程中的任务
        backgroundHandler = Handler(handlerThread.looper) // 创建一个 Handler 对象，并将 HandlerThread 的 Looper 对象传递给它。
        // 这样 Handler 就可以将任务提交到 HandlerThread 的消息队列中执行

        backgroundHandler.post { // 使用 Handler 将一个 Runnable 对象（lambda 表达式）提交到 HandlerThread 的消息队列中执行
            val result = doTimeConsumingOperation() // 在后台线程中执行一个耗时的操作
            runOnUiThread { // 使用 runOnUiThread 方法将一个 Runnable 对象提交到主线程执行
                // 更新UI，例如TextView.setText(result) // 在主线程中更新 UI 界面，例如将 TextView 的文本设置为后台操作的结果
            }
        }
    }

    private fun doTimeConsumingOperation(): String { // 定义一个耗时的操作，模拟在后台线程中执行的任务
        // 模拟耗时操作
        Thread.sleep(3000) // 模拟线程休眠 3 秒钟
        return "HandlerThread 操作完成" // 返回一个字符串，表示后台操作完成
    }

    override fun onDestroy() { // 在 Activity 销毁时调用
        super.onDestroy()
        handlerThread.quitSafely() // 安全地停止 HandlerThread，确保所有未处理的消息都处理完毕后再停止线程
    }
}

使用AsyncTask（注意：AsyncTask在新项目中已不推荐使用）
AsyncTask曾一度很流行，其封装了耗时任务与UI线程的自动切换，但在新版Android中已被弃用。下面仅作为示例参考：

import android.os.AsyncTask
import android.os.Bundle
import androidx.appcompat.app.AppCompatActivity

class AsyncTaskExampleActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_async_task_example)

        MyAsyncTask().execute("参数")
    }

    inner class MyAsyncTask : AsyncTask<String, Void, String>() {
        override fun doInBackground(vararg params: String?): String {
            // 在这里执行耗时操作
            Thread.sleep(3000)
            return "AsyncTask 操作完成"
        }

        override fun onPostExecute(result: String?) {
            super.onPostExecute(result)
            // 在主线程更新UI
        }
    }
}

使用Kotlin协程
协程是当前最佳实践，下面是一个把耗时操作放入异步执行的实例，结合LifeCycle安全的lifecycleScope使用：

import android.os.Bundle
import androidx.appcompat.app.AppCompatActivity
import androidx.lifecycle.lifecycleScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.delay
import kotlinx.coroutines.launch
import kotlinx.coroutines.withContext

/*
lifecycleScope 是 Android KTX 库提供的一个扩展属性，它为 LifecycleOwner 提供了一个与组件生命周期绑定的 CoroutineScope
它可以简化协程管理，避免内存泄漏，并与组件生命周期绑定。
 */
class CoroutineExampleActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_coroutine_example)

        // 启动协程处理耗时操作
        lifecycleScope.launch {
            // 切换到IO线程执行耗时任务
            val result = withContext(Dispatchers.IO) {
                doTimeConsumingOperation()
            }
            // 回到主线程更新UI
            updateUI(result)
        }
    }

    private suspend fun doTimeConsumingOperation(): String {
        // 模拟耗时操作，例如网络请求或文件IO
        delay(3000)
        return "协程操作完成"
    }

    private fun updateUI(result: String) {
        // 更新UI，例如TextView.setText(result)
    }
}

在上述协程示例中，我们使用了lifecycleScope，这是Android组件（如Activity或Fragment）配合协程的一种安全方式，能够在组件销毁时自动取消协程任务。withContext(Dispatchers.IO)则切换到了IO线程中来执行任务，而delay()函数是挂起函数，不会阻塞线程。

────────────────────────────── 【七、注意事项与最佳实践】

在将耗时操作放入异步执行的过程中，需要注意以下几点：

线程切换：
确保所有UI更新操作必须在主线程中执行。Android规定只有主线程可以操作UI，因此在耗时任务完成后，通过Handler、runOnUiThread或协程切换回Dispatchers.Main更新界面。
线程安全：
当多个线程同时访问共享数据时，要注意线程安全问题。可以使用同步锁（synchronized）或者其他并发控制手段（如Mutex、Atomic变量等）来确保数据一致性。
取消与异常处理：
尤其是协程中，要设计好取消机制（例如在Activity销毁时取消协程）以及捕获异常，确保不会因为未处理的异常导致崩溃。可以使用try-catch捕获协程异常，或者在launch时配置异常处理器。
资源管理：
异步任务完成后，要及时释放资源，例如关闭线程、停止HandlerThread等，防止资源泄露。
性能测试：
将任务放入异步线程后，最好使用Trace、Systrace、Hierarchy Viewer等工具监控性能，确保实际效果满足预期。注意测量任务切换、排队、回调等环节的额外开销，优化整体执行效果。
多任务与并发：
如果有大量耗时任务需要并发执行时，选择合适的线程池非常重要。可以通过Executors.newFixedThreadPool设置固定数量的线程，防止创建过多线程导致资源耗尽。
考虑任务优先级：
对于不同的任务，可以根据优先级进行调度。例如，将高优先级任务分配给单独的线程或单独的Dispatcher处理，确保关键路径任务不会被延迟。

────────────────────────────── 【八、实践中的案例和经验总结】

网络请求类型操作：
在实际应用中，如使用Retrofit进行网络请求，本质上Retrofit内部已经配合OkHttp实现多线程操作，但是需要注意配合协程或回调正确处理UI更新。例如：

// Retrofit接口配合协程实现（示例代码）
interface ApiService {
    @GET("users")
    suspend fun getUsers(): List<User>
}

配合lifecycleScope使用：

lifecycleScope.launch {
    try {
        val users = apiService.getUsers() // IO耗时操作自动在后台线程执行
        updateUI(users)
    } catch (e: Exception) {
        // 处理网络异常
    }
}

数据库访问：
现代Android开发中，使用Room数据库时推荐使用协程和LiveData，将数据库操作放在IO线程中。例如：

lifecycleScope.launch {
    val userList = withContext(Dispatchers.IO) {
        userDao.getAllUsers() // 数据库查询放在IO线程中
    }
    // 在主线程更新界面
    adapter.submitList(userList)
}

长时间计算或文件IO：
例如，处理大图像时，先在IO线程中加载和处理图片数据，再将处理好的图片加载到UI界面中。合理的线程切换可以避免主线程被长时间占用，保证动画和用户交互的流畅性。
使用协程进行多个耗时任务的组合：
协程支持并行任务的组合和等待，通过async/await可以并发执行多个独立的任务，然后收集结果。例如：

lifecycleScope.launch {
    val deferredResult1 = async(Dispatchers.IO) { doTask1() }
    val deferredResult2 = async(Dispatchers.IO) { doTask2() }
    // 等待两个任务完成
    val result1 = deferredResult1.await()
    val result2 = deferredResult2.await()
    updateUI(result1, result2)
}

这种方式不仅能充分利用多核能力，还能合并多个异步结果，达到优化整体性能的目的。

[面试问题]

────────────────────────────── 【面试官】
请简单介绍一下你对“耗时操作放入异步”的理解，这在性能优化中起到什么作用？

【回答】
耗时操作指的是那些在执行时会导致主线程阻塞、延迟响应的任务，比如网络请求、大量的数据计算、磁盘I/O等。如果这些操作直接在主线程中执行，就会造成界面卡顿甚至ANR现象。将这些耗时操作放入异步线程，就可以让主线程主要专注于UI更新和用户交互，而后台线程负责完成耗时任务。这样一来，当任务完成后再通过回调或线程切换将结果传回主线程，也就能确保用户体验的流畅性。整体来说，这种方式即保证了功能实现，也大幅降低了用户等待时间，是Android性能优化的重要手段之一。

────────────────────────────── 【面试官】
那你能具体说明一下常见的将耗时操作放入异步执行的方式有哪些吗？并谈谈各自的优缺点？

【回答】
常见的将耗时操作放入异步执行的方式主要有以下几种：

使用 Java 的原生 Thread 和 Runnable：
这种方式比较直观，直接新建线程去跑耗时任务，然后使用 Handler 或 runOnUiThread 切换回主线程更新UI。优点是概念简单，缺点是需要手动管理线程的创建、销毁与线程安全问题，写起来稍显冗杂。
使用 HandlerThread 搭配 Handler：
HandlerThread 可以创建一个拥有消息循环的子线程，结合 Handler 可以轻松地队列化任务。这样不仅减轻了频繁创建线程的负担，还能让任务以消息的形式排队执行。但它的局限在于任务管理较为固定，适用于需要顺序处理耗时任务的场景，对于并行处理场景而言可能不够灵活。
使用 ExecutorService：
线程池是一种更高效的管理多个线程的工具，可以根据需要创建固定数量甚至动态扩展的线程，并管理任务队列。它可以有效避免频繁创建线程所带来的性能开销。但使用后还需关注线程池的配置、任务拒绝政策以及及时释放资源。
使用 RxJava：
RxJava 提供了丰富的异步编程模型，通过 Observable 或 Single 等类型结合 Schedulers 能够非常方便地在不同线程间切换，并具备优雅的错误处理和取消机制。优点是表达力强、支持组合多个异步操作；缺点是需要掌握不少响应式编程的概念，且结构复杂时容易出现“回调地狱”的问题，不过合理使用可以避免。
使用 Kotlin 协程：
协程是目前非常流行的异步方案，能够让代码看起来像是同步执行，从而大大提升可读性和维护性。借助 suspend 函数、launch 等机制以及逐步调整调度器（如 Dispatchers.IO 与 Dispatchers.Main），我们可以方便地实现将耗时操作放入后台线程，同时保证UI操作在主线程中执行。优点是语法简洁、错误处理和任务取消机制更容易管理，缺点则在于需要理解协程背后的调度器和作用域，否则可能会出现资源泄漏或取消不及时的问题。

────────────────────────────── 【面试官】
能否举个实际场景的例子，说明如何将耗时操作异步化，以及这会如何提升用户体验？

【回答】
举个例子来说，比如一个电商App中，在用户点击“刷新”或使用首页时需要加载大量的商品数据。如果在主线程中进行网络请求和数据解析，一旦遇到网络延迟或服务器响应缓慢，就会导致屏幕卡顿，使用户感觉整个应用反应迟钝。而采用异步方式，将网络请求、数据解析放到后台线程中进行，在任务完成时再通过回调更新UI，用户在主页展示时就能立刻看到骨架屏或部分数据，从而减少等待时间。这样的改造不仅能够提高数据加载的效率，同时也保证了用户交互的流畅性，大大提升了应用的用户体验。

────────────────────────────── 【面试官】
在实现异步操作过程中，你认为有哪些需要特别注意的问题？比如线程安全、异常处理等方面。

【回答】
在实际实现中，有几点非常需要注意：

线程安全问题：在多个线程操作共享数据时，必须确保同步机制，否则可能会引发数据不一致或竞态条件。这就需要合理地对共享变量进行加锁或采用线程安全的数据结构。
异常处理：异步任务中如果出现异常，一定要捕获并处理，否则可能导致整个异步任务中断，也会引发难以追踪的问题。无论是 RxJava、协程还是其它方式，都需要有相应的异常处理机制，比如 try-catch 或通过相应的错误回调将异常信息传递给UI层，确保应用不会崩溃。
任务取消机制：当用户离开页面或应用进入后台后，仍在运行的耗时任务必须能够及时取消。这不仅可以节省资源，还能防止因回调更新UI而发生内存泄漏。对于协程和 RxJava，都提供了取消订阅或取消任务的方法，所以在使用中需要注意在生命周期结束时正确取消任务。
资源管理：启动大量线程或任务时，还需要考虑系统资源的利用。比如线程池应当合理配置，避免同时开启太多线程，从而引发系统调度负担，反而影响整体性能。
UI线程切换：无论异步任务内部如何处理数据，最终更新UI的操作必须在主线程上完成，这需要通过相应的方案把任务结果转移回主线程。比如 Handler、runOnUiThread、协程中的 Dispatchers.Main 都是常用的方式。

────────────────────────────── 【面试官】
你认为现在在Android开发中，比较推荐使用哪种异步处理方案来处理耗时操作？理由是什么？

【回答】
目前在Android开发中，Kotlin协程可以说是最受推荐的异步处理方案。理由主要有以下几点：

协程能够简化异步代码的编写，使得逻辑看起来像同步代码，降低了代码的复杂度和错误率。
协程内置取消机制，结合生命周期作用域（如 lifecycleScope），可以方便地管理任务，在Activity或Fragment销毁时自动取消未完成的任务，确保不会出现内存泄漏。
协程支持灵活的线程调度，我们可以通过 withContext 切换到合适的线程处理不同类型的任务（例如 I/O 操作、CPU 密集型计算等），并最终在主线程更新 UI。
相比于传统的线程和HandlerThread，以及RxJava那种需要引入响应式编程框架，协程的语法更简洁，学习曲线也相对平缓，整体开发体验更优。
当然，如果在某些特定的场景中，例如需要构建复杂的异步流操作时，RxJava可能会更适合，但总体来说，协程已经成为当前Android开发中热门的解决方案。

────────────────────────────── 【面试官】
让我们深入一点，请谈谈在将耗时操作放入异步实现时，如何协调任务执行与主线程更新之间的关系，以及如何避免因切换导致的上下文切换开销。

【回答】
这其实涉及到任务分解和线程切换的策略。通常，耗时操作我们可以将整个处理过程拆分为两部分：一部分是在后台线程完成数据加载、处理或者计算，另一部分则是最后在主线程中更新界面。现代异步框架，如Kotlin协程，允许我们通过 withContext 来明确指定某段代码在哪个线程中运行。这样，我们可以确保整个耗时任务在后台执行，然后只将必须在主线程更新UI的部分放在 Dispatchers.Main 上来执行。

关于上下文切换的开销，虽然线程切换操作本身会引入一些开销，但相比于耗时任务（例如网络或文件I/O）的时间来说，这部分开销可以忽略。如果使用协程等轻量级线程方案，可以大大降低这种切换的消耗。总体来说，我们需要保证在后台完成重载任务的同时，不频繁地在主线程与其他线程之间切换，最好是将整个任务在后台线程运行完毕后，再统一切换到主线程进行一次性更新，从而达到性能和用户体验之间的平衡。

────────────────────────────── 【面试官】
在你的实际项目中，你曾经使用异步方式处理过耗时操作吗？具体是如何实施的？可以简单描述一下你遇到的问题及解决方案吗？

【回答】
在实际项目中，我曾经遇到过在用户点击进入某个详情页时需要加载大量数据和图片的问题。当时发现如果直接在主线程中处理这些耗时任务，会导致用户体验非常卡顿。解决方案主要是采用 Kotlin 协程，将网络请求和图片处理等操作放入 Dispatchers.IO 背景线程进行处理，然后在数据加载完毕后，通过 Dispatchers.Main 更新UI。具体而言，我们在ViewModel中启动了预加载任务，同时利用 LiveData 或 StateFlow 将数据传递给UI。这样不仅实现了优雅的线程切换，还极大地避免了因任务取消不当而导致的内存泄漏。我还注意到在实际过程中要特别关注异常处理以及任务的取消时机，当用户退出页面时，必须及时取消未完成的后台任务，防止无效的更新或资源浪费。