重用协程范围的有效方法？

Question

所以我有一个具有生命周期的类，其中包含一个 start() 和一个 stop() 函数来启动和停止生命周期。现在在start() 函数中我必须启动一个协程，在stop() 我必须取消它（start() 中的协程无限运行直到它被取消，有点像监听消息的套接字）。

因为我想要一个很好的语法来处理协程，所以我希望这个类实现CoroutineScope。问题是start() 和stop() 可以被多次调用。

我的问题是这个实现是否有效并且不包含任何错误。目的是制作一个可重复使用的CoroutineScope。

class ReusableCoroutines() : CoroutineScope {

    private var job = Job()

    override val coroutineContext: CoroutineContext
        get() = job

    fun start() {
        job = Job()
        launch {
            println("Started and running!")
            while(true) {

            }
        }
    }

    fun stop() {
        job.cancel()
        println("Stoped")
    }

}

Answer 1

免责声明：我不会这样做。除非您每秒创建数千个可重用对象，否则您不会从可重用对象中获得太多收益。我只创建在创建时初始化的一次性类（没有start 函数），然后在调用stop 时创建cancelled。话虽如此，这可能有效：

class ReusableCoroutines(
        private val scope: CoroutineScope = CoroutineScope(Dispatchers.Default)
) : CoroutineScope by scope {

    private lateinit var job: Job
    private var stopped: Boolean = false
    private var started: Boolean = false

    @Synchronized
    fun start() {
        require(stopped.not()) {
            "Already stopped!"
        }
        require(started.not()) {
            "Already started!"
        }
        job = launch {
            println("Started and running!")
            while (true) {

            }
        }
    }

    @Synchronized
    fun stop() {
        require(stopped.not()) {
            "Already stopped!"
        }
        stopped = true
        cancel()
        println("Stopped")
    }

}

所以你需要一些同步 @Synchronized 来防止开始被多个线程调用并最终处于不一致的状态。

您还可以将scope 作为参数，这样您就可以获得结构化并发。您还可以在scope 中添加SupervisorJob，以防止在您取消此范围时取消父级。