Question

我有List个参数用于执行下载。我正在将该列表的元素映射到执行下载的Deferred中；然后，将列表中的forEach元素称为await，但显然下载是按顺序执行的。

这是我的功能：

suspend fun syncFiles() = coroutineScope {
    remoteRepository.requiredFiles()
        .filter { localRepository.needToDownload( it.name, it.md5 ) }
        .map { async { downloader( it ) } }
        .forEach { deferredResult ->

            when ( val result = deferredResult.await() ) {
                is DownloadResult.Layout ->  localRepository.storeLayout( result.content )
                is DownloadResult.StringR -> localRepository.storeFile( result )
            }
        }
}

这是我的测试

private val useCase = SyncUseCaseImpl.Factory(
        mockk { // downloader
            coEvery { this@mockk.invoke( any() ) } coAnswers { delay(1000 );any() }
        },
        ...
    ).newInstance()

@Test
fun `syncFiles downloadConcurrently`() = runBlocking {
    val requiredFilesCount = useCase.remoteRepository.requiredFiles().size
    assert( requiredFilesCount ).isEqualTo( 3 )

    val time = measureTimeMillis {
        useCase.syncFiles()
    }

    assert( time ).isBetween( 1000, 1100 )
}

这是我的结果：expected to be between:<1000L> and <1100L> but was:<3081L>

我认为很奇怪，因为这2个虚拟测试正确完成，也许我遗漏了一些东西（？）

@Test // OK
fun test() = runBlocking {
    val a = async { delay(1000 ) }
    val b = async { delay(1000 ) }
    val c = async { delay(1000 ) } 
    val time = measureTimeMillis {
        a.await()
        b.await()
        c.await()
    } 
    assert( time ).isBetween( 1000, 1100 )
} 

@Test // OK
fun test() = runBlocking {
    val wasteTime: suspend () -> Unit = { delay(1000 ) }
    suspend fun wasteTimeConcurrently() = listOf( wasteTime, wasteTime, wasteTime )
            .map { async { it() } }
            .forEach { it.await() } 
    val time = measureTimeMillis {
        wasteTimeConcurrently()
    } 
    assert( time ).isBetween( 1000, 1100 )
}

Answer 1

问题出在mockk

如果您查看coAnswer函数的代码，则会发现以下内容（API.kt + InternalPlatformDsl.kt）：

infix fun coAnswers(answer: suspend MockKAnswerScope<T, B>.(Call) -> T) = answers {
    InternalPlatformDsl.runCoroutine {
        answer(it)
    }
}

runCoroutine看起来像这样。

actual fun <T> runCoroutine(block: suspend () -> T): T {
    return runBlocking {
        block()
    }
}

如您所见，coAnswer是一个非暂停功能，并以runBlocking开始一个新协程。

让我们看一个例子：

val mock =  mockk<Downloader> {
    coEvery {
        this@mockk.download()
    } coAnswers {
        delay(1000)
    }
}

val a = async {
    mock.download()
}

当mockk执行coAnswer块（delay()）时，它将启动人工协程范围，执行给定的块并等待（阻塞当前线程：runBlocking ），直到该程序段结束。因此，只有在delay(1000)完成之后，答案块才会返回。

意味着从coAnswer运行的所有协程将被顺序执行。

Answer 2

如果作业阻塞了整个线程，则可能发生这种情况，例如，IO绑定的任务阻塞了整个线程的执行，从而阻塞了该线程上的所有其他协程。如果您使用的是Kotlin JVM，请尝试调用async(IO) { }来在IO调度程序下运行Couroutine，以便Couroutine环境现在知道该作业将阻塞整个线程并相应地执行操作。

在这里寻找其他调度员：https://kotlinlang.org/docs/reference/coroutines/coroutine-context-and-dispatchers.html#dispatchers-and-threads

协程：列表中的延迟操作按顺序运行。

2 个答案: