如何停止协程？协程计数器实现的正确性与简化方案问询

当前实现的问题 #

你的代码存在几个明显问题，无法正确保证协程安全结束：

• 空安全隐患：stopJob() 中直接调用 job.isActive，但 job 可能为 null，会触发空指针异常。
• 协程执行时机失效：通过 coroutineScope?.launch 执行 cancelAndJoin()，但紧接着就调用 coroutineScope?.cancel()，新启动的协程可能还未执行就被取消，导致 cancelAndJoin() 无法生效。
• 状态重置时机错误：counter = 0 在协程未完全结束时就执行，会出现协程后续打印的计数器值与实际状态不一致的情况。
• 冗余的Job存储：单独维护 job 没有必要，CoroutineScope 本身可以管理所有子协程，无需额外持有单个Job引用。

修正后的正确实现 #

class Counter {
    private var coroutineScope: CoroutineScope? = null
    private var counter = 0
    
    fun startJob() {
        stopJob()
        coroutineScope = CoroutineScope(Dispatchers.Main)
        coroutineScope?.launch {
            while (isActive) {
                counter++
                println("counter: $counter")
                delay(2000)
            }
        }
    }

    fun stopJob() {
        val scope = coroutineScope ?: return
        runBlocking {
            scope.cancelAndJoin()
        }
        coroutineScope = null
        counter = 0
    }

    companion object {
        @JvmStatic
        fun main(args: Array<String>) {
            val counter = Counter()
            counter.startJob()
            Thread.sleep(5000)
            counter.stopJob()
            println("Job stopped, counter reset to ${counter.counter}")
        }
    }
}

关键改进点：

• 用 runBlocking 同步等待协程作用域的所有子协程结束（适配非协程环境调用场景）
• 直接通过 CoroutineScope 的 cancelAndJoin() 管理所有子协程，移除冗余的 job 变量
• 确保协程完全结束后再重置 counter 和清空作用域引用

更简洁的实现方案 #

利用 CoroutineScope 特性和 MutableStateFlow 简化状态管理，同时规范协程生命周期：

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.asStateFlow

class Counter {
    private val scope = CoroutineScope(Dispatchers.Main + SupervisorJob())
    private val _counter = MutableStateFlow(0)
    val counter = _counter.asStateFlow() // 对外暴露只读状态流

    fun startJob() {
        stopJob()
        scope.launch {
            while (isActive) {
                _counter.value++
                delay(2000)
            }
        }
    }

    fun stopJob() {
        scope.coroutineContext.job.cancelChildren() // 取消所有子协程
        _counter.value = 0
    }

    fun release() { // 统一释放作用域，避免内存泄漏
        scope.cancel()
    }

    companion object {
        @JvmStatic
        fun main(args: Array<String>) = runBlocking {
            val counter = Counter()
            counter.startJob()
            
            // 监听计数器变化
            counter.counter.collect {
                println("counter: $it")
            }
            
            delay(5000)
            counter.stopJob()
            counter.release()
        }
    }
}

方案优势：

• 用 StateFlow 自动管理计数器状态，避免手动维护和状态不一致问题
• 借助 SupervisorJob 确保单个子协程取消不影响整个作用域
• 取消协程时直接调用 cancelChildren()，状态重置更安全高效
• 增加 release() 方法规范作用域释放，避免内存泄漏

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