如何使Coroutines仅在第一次完成后才启动下一份工作

Question

假设我有一个按钮，它在Android中有一个侦听器：

someView.setOnClickListener {
    viewModel.doSomething()
}

每次按下按钮时，这都会创建一个新工作。在我的ViewModel中，Dosothing函数正在从ViewModelScope启动暂停函数：

fun doSomething() {
  viewModelScope.launch {
       doSomething1()
       doSomething2()
       doSomething3() 
   }
}

suspend fun doSomething1() {
    delay(100)
    Log.d("TEST", "doSomething1: 1 ")
}

suspend fun doSomething2() {
    delay(300)
    Log.d("TEST", "doSomething2: 2 ")
}

fun doSomething3() {
    Log.d("TEST", "doSomething3: 3 ")
}

现在，如果此按钮连续地按非常快速按下（从理论上讲，我可以两次从听众中调用该功能，以便执行第一个呼叫尚未完成），我将在我的logcat中得到以下结果：

  d/test：Dosomething 1：1
D/测试：Dosomething 1：1
D/测试：Dosomething 2：2
D/测试：Dosomething 3：3
D/测试：Dosomething 2：2
D/测试：Dosomething 3：3
 

我实际想实现的是，如果我可以从同一范围启动dosomething（），将会发生什么，因此它运行同步。

  d/test：Dosomething 1：1
D/测试：Dosomething 1：2
D/测试：Dosomething 2：3
D/测试：Dosomething 3：1
D/测试：Dosomething 2：2
D/测试：Dosomething 3：3
 

我该如何实现这种行为，以便在开始同一个Coroutine之前，必须完成第一个行为？

Answer 1

您可以使用MUTEX锁来执行此操作 - 无论您按下多少次按钮，锁定锁定序列都无法启动直到完成。

private val lock = Mutex()

fun doSomething() {
  viewModelScope.launch {
       // lock means only one "1-2-3" sequence can execute 
       // at a time, subsequent calls will suspend here and wait
       // for the lock to be released before starting
       lock.withLock {
           doSomething1()
           doSomething2()
           doSomething3() 
       }
   }
}

您也可以使用频道一次运行一个频道

private val channel = Channel<Job>(capacity = Channel.UNLIMITED).apply {
    viewModelScope.launch {
        consumeEach { it.join() }
    }
}

fun doSomething() {
    channel.trySend(
        // send a lazily executed "1-2-3" job to the channel for it
        // to run (will run jobs one at a time and wait for each
        // job to complete before starting the next)
        viewModelScope.launch(start = CoroutineStart.LAZY) {
            doSomething1()
            doSomething2()
            doSomething3() 
        } 
    )
}

Answer 2

可以通过保存最后一份工作并等待完成新的Coroutine来解决：

private var lastJob: Job? = null

fun doSomething() {
    val prevJob = lastJob
    lastJob = lifecycleScope.launch {
        prevJob?.join()
        doSomething1()
        doSomething2()
        doSomething3()
    }
}