Considere este código a continuación, estoy tratando de usar Executors.newFixedThreadPool(1).asCoroutineDispatcher() para crear un despachador de hilo único; Quiero que el código dentro de launch(singleThread){...} se ejecute secuencialmente
el resultado esperado debería ser como el siguiente porque async-block#2 alcanza/adquiere singleThread primero
bloque asíncrono #2
bloque asíncrono #1
bloque de un solo hilo #2
bloque de un solo hilo #1
la respuesta es 3
pero el resultado real es
bloque asíncrono #2
bloque asíncrono #1
bloque de un solo hilo #1
bloque de un solo hilo #2
la respuesta es 3
single-thread-block-#2 y single-thread-block-#1 parecen ejecutarse en paralelo, singleThread no hace ninguna diferencia aquí
import java.util.concurrent.Executors import kotlinx.coroutines.* import kotlin.system.* val singleThread = Executors.newFixedThreadPool(1).asCoroutineDispatcher() fun main() = runBlocking<Unit> { val time = measureTimeMillis { val one = async { // async block #1 delay(200) println("async block #1") launch (singleThread) { delay(500) println("single thread block #1") } 2 } val two = async { // async block #2 delay(100) println("async block #2") launch (singleThread) { delay(1500) println("single thread block #2") } 1 } println("The answer is ${one.await() + two.await()}") } println("Completed in $time ms") }Tenga en cuenta que el delay() es la función de suspend en el código. Se implementa a través de la suspensión coroutine. Significa que la ejecución del código se suspende en el momento en que solicita el delay y solo se reanuda después del tiempo de espera. El subproceso (por ejemplo, uno que usa a través de async(singleThread) {..} no está ocupado esperando que transcurra el tiempo.
El escenario general se ve así
singleThreaddelay(1500) , el singleThread es gratissingleThreaddelay(500) , el singleThread es gratisdelay(500) para la tarea 1delay(1500) para la tarea 2resume(500) programa la segunda parte de la tarea 1 para que se ejecute en singleThreadresume(1500) programa la segunda parte de la tarea 2 para que se ejecute en singleThreadAdemás de la respuesta de @EugenePetrenko, hay un nuevo método CoroutineDispatcher.limitedParallelism(numberOfParallelism) , que puede usar para garantizar la restricción de paralelismo: se puede ejecutar como máximo 1 coroutine simultáneamente en este despachador. Se verá como:
val singleThread = Dispatchers.IO.limitedParallelism(1) someCoroutineScope.launch (singleThread) { ... } La función limitedParallelism está disponible a partir de la versión 1.6.0 de la biblioteca kotlinx.coroutines .