如何用Kotlin协程实现待执行操作的有序队列？

针对你遇到的ANR问题，结合Kotlin协程官方最佳实践，这里提供一套更简洁、可维护的方案，核心是用单线程串行调度的CoroutineScope替代手动线程池+runBlocking的组合，同时完美支持UI/后台混合逻辑。

完整代码实现 #

import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.SupervisorJob
import kotlinx.coroutines.launch
import kotlinx.coroutines.withContext
import android.content.BroadcastReceiver
import android.content.Context
import android.content.Intent

class SerialTaskBroadcastReceiver : BroadcastReceiver() {
    // 单线程串行执行的CoroutineScope：保证所有onReceive任务按顺序排队执行
    private val serialTaskScope = CoroutineScope(
        SupervisorJob() + Dispatchers.Default.limitedParallelism(1)
    )

    override fun onReceive(context: Context, intent: Intent) {
        val pendingResult = goAsync()
        serialTaskScope.launch {
            try {
                // 封装混合逻辑的处理方法
                handleReceivedTask(context, intent)
            } finally {
                // 无论任务成功/失败，必须调用finish释放BroadcastReceiver资源
                pendingResult.finish()
            }
        }
    }

    private suspend fun handleReceivedTask(context: Context, intent: Intent) {
        // 1. 切换到UI线程执行UI相关检查
        val uiCheckPassed = withContext(Dispatchers.Main) {
            someCheckOnUiThread()
        }

        if (uiCheckPassed) {
            // 2. 切换到后台线程执行数据库/存储操作
            val dbOperationSuccess = withContext(Dispatchers.IO) {
                someDbOperation()
            }

            if (dbOperationSuccess) {
                // 3. 切回UI线程执行后续UI更新
                withContext(Dispatchers.Main) {
                    updateUiAfterSuccess()
                }
            }
        }
    }

    // 示例UI线程检查方法（仅能在UI线程执行）
    private fun someCheckOnUiThread(): Boolean {
        // 比如检查UI状态、获取View数据等
        return true
    }

    // 示例后台耗时操作（需避免UI线程执行）
    private fun someDbOperation(): Boolean {
        // 比如Room数据库查询、文件读写等
        return true
    }

    // 示例UI更新方法
    private fun updateUiAfterSuccess() {
        // 更新UI状态、弹出提示等
    }
}

关键优化点解析 #

1. 串行任务保障

   • 用Dispatchers.Default.limitedParallelism(1)替代手动创建FixedThreadPool：既保证同一时间只执行一个任务（天然串行），又复用Kotlin协程的线程池资源，符合官方性能最佳实践。
   • SupervisorJob确保单个任务失败不会中断后续任务的执行，适合BroadcastReceiver这种独立任务场景。

2. 线程切换更优雅

   • 用withContext替代runInterruptible+runBlocking：withContext是协程官方推荐的线程切换方式，会挂起协程而非阻塞线程，彻底避免不必要的线程阻塞风险。
   • UI/后台逻辑拆分清晰：通过withContext(Dispatchers.Main)和withContext(Dispatchers.IO)明确区分不同线程的操作，代码可读性和可维护性大幅提升。

3. 生命周期安全

   • 用try-finally强制保证pendingResult.finish()被调用，避免BroadcastReceiver资源泄漏。
   • 如果是动态注册的Receiver，可在组件销毁时调用serialTaskScope.cancel()，取消所有待执行任务，防止内存泄漏。

扩展：通用串行任务工具 #

如果这个串行需求不限于BroadcastReceiver，可封装成通用工具类复用：

object SerialTaskExecutor {
    private val serialScope = CoroutineScope(SupervisorJob() + Dispatchers.Default.limitedParallelism(1))

    fun execute(task: suspend () -> Unit) {
        serialScope.launch { task() }
    }
}

// 使用示例
SerialTaskExecutor.execute {
    val uiCheck = withContext(Dispatchers.Main) { /* UI线程操作 */ }
    if (uiCheck) {
        val result = withContext(Dispatchers.IO) { /* 后台耗时操作 */ }
        withContext(Dispatchers.Main) { /* UI后续操作 */ }
    }
}

内容的提问来源于stack exchange，提问作者android developer