Solución:
De acuerdo, las corrutinas se comparan más a menudo con subprocesos que con las tareas que ejecuta en un grupo de subprocesos determinado. Un Ejecutor es ligeramente diferente en el sentido de que tiene algo que administra subprocesos y pone en cola las tareas para que se ejecuten en esos subprocesos.
También confesaré que solo he estado usando los courotines y actores de Kotlin de manera sólida durante unos 6 meses, pero continuemos.
IO asíncrono
Entonces, creo que una gran diferencia es que ejecutar su tarea en una corrutina le permitirá lograr la concurrencia en un solo subproceso para una tarea de E / S si esa tarea es una tarea de E / S verdaderamente asíncrona que proporciona el control de manera adecuada mientras la tarea de E / S aún se está completando. . Puede lograr lecturas / escrituras concurrentes muy ligeras con corrutinas de esta manera. Podrías lanzar 10 000 corrutinas todas leyendo desde el disco al mismo tiempo en 1 hilo y sucedería al mismo tiempo. Puede leer más sobre async IO aquí async io wiki
Por otro lado, para un servicio Executor, si tuviera 1 subproceso en su grupo, sus múltiples tareas IO se ejecutarían y bloquearían en serie en ese subproceso. Incluso si estuviera utilizando una biblioteca asincrónica.
Simultaneidad estructurada
Con las corrutinas y el alcance de las corrutinas, obtienes algo llamado concurrencia estructurada. Esto significa que tiene que llevar mucho menos libros sobre las diversas tareas en segundo plano que está ejecutando para que pueda realizar una limpieza adecuada de esas tareas si ingresa en alguna ruta de error. Con su albacea, necesitaría realizar un seguimiento de su futuro y hacer la limpieza usted mismo. Aquí hay un artículo realmente bueno escrito por uno de los miembros del equipo de kotlin que explica completamente esta sutileza. Simultaneidad estructurada
Interacción con actores
Otra ventaja, probablemente más de nicho, es que con las corrutinas, los productores y los consumidores, puede interactuar con los actores. Los actores encapsulan el estado y logran una concurrencia segura para subprocesos a través de la comunicación en lugar de a través de las herramientas sincronizadas tradicionales. Usando todos estos, puede lograr un estado muy ligero y altamente concurrente con muy poca sobrecarga de subprocesos. Los ejecutores simplemente no ofrecen la capacidad de interactuar con el estado sincronizado en algo como un actor con, por ejemplo, 10 000 hilos o incluso 1000 hilos. Con mucho gusto podría lanzar 100 000 corrutinas, y si las tareas se suspenden y el control de rendimiento en los puntos adecuados, puede lograr algunas cosas excelentes. Puede leer más aquí Estado mutable compartido
Peso ligero
Y finalmente, solo para demostrar cuán liviana es la concurrencia de corrutinas, lo desafiaría a hacer algo como esto en un ejecutor y ver cuál es el tiempo total transcurrido (esto se completó en 1160 milisegundos en mi máquina):
fun main() = runBlocking {
val start = System.currentTimeMillis()
val jobs = List(10_000){
launch {
delay(1000) // delays for 1000 millis
print(".")
}
}
jobs.forEach { it.join() }
val end = System.currentTimeMillis()
println()
println(end-start)
}
Probablemente haya otras cosas, pero como dije, todavía estoy aprendiendo.