Las corutinas son excelentes características disponibles en el idioma Kotlin. Ya lo probé y realmente me gustó.
El propósito de este artículo es ayudarlo a comprender Corutins. Solo tenga cuidado al leer y tendrá éxito.
Comencemos con la definición oficial de Corutin.
Las rutinas son una nueva forma de escribir código asincrónico sin bloqueo.
La primera pregunta que surge al leer esta definición es ¿en qué se diferencian las Corutinas de los flujos?
Las corutinas son flujos ligeros. Un subproceso ligero significa que no está vinculado al subproceso nativo, por lo tanto, no requiere cambiar el contexto al procesador, por lo tanto, es más rápido.
¿Qué significa "no conectado al hilo nativo" ?
Las rutinas se encuentran en muchos lenguajes de programación.
Básicamente, hay dos tipos de corutina:
- usando la pila;
- pila sin uso;
Kotlin implementa Coroutines sin una pila, esto significa que las Coroutines no tienen su propia pila, por lo que no están vinculadas al hilo nativo.
Tanto Coroutines como streams son multitarea. Pero la diferencia es que los subprocesos están controlados por el sistema operativo y las Coroutinas son por los usuarios.
Ahora puede leer y comprender conscientemente el extracto del sitio web oficial de Kotlin:
Las corutinas pueden representarse en forma de flujo facilitado. Al igual que los hilos, las corutinas pueden trabajar en paralelo, esperar el uno al otro y comunicarse. La mayor diferencia es que las corutinas son muy baratas, casi gratuitas: podemos crearlas en miles y pagar muy poco en términos de rendimiento. Las corrientes son caras. Mil hilos pueden ser un problema grave incluso para una máquina moderna.
Veamos cómo trabajar con Coroutines.
Entonces, ¿cómo comenzar la rutina (similar a comenzar un hilo)?
Hay dos funciones para lanzar corutinas:
lanzar {} vs async {} en Kotlin Coroutines
La diferencia es que launch{} no devuelve nada, y async{} devuelve una instancia Deferred que tiene una función wait await() que devuelve el resultado de una rutina, al igual que Future en Java, donde hacemos future.get() para obtener el resultado .
Echemos un vistazo al uso del lanzamiento {}
fun main(args: Array<String>) { println("Kotlin Start") launch(CommonPool) { delay(2000) println("Kotlin Inside") } println("Kotlin End") }
// The output will be // Kotlin Start // Kotlin End // Kotlin Inside
Este código lanzará una nueva rutina en este grupo de subprocesos. En este caso, usamos CommonPool , que usa ForkJoinPool.commonPool () . Las secuencias todavía existen en un programa basado en corutina, pero un subproceso puede ejecutar muchas corrutinas, por lo que no hay necesidad de demasiados hilos.
Probemos una cosa:
fun main(args: Array<String>) { delay(2000) }
Si hace esto directamente en la función principal, recibirá un mensaje de error:
Las funciones de interrupción solo se pueden llamar desde la rutina u otra función de interrupción.
La función de retraso es una función de interrupción, por lo que solo podemos llamarla desde una función de interrupción de rutina u otra.
Vamos a arreglar esto:
fun main(args: Array<String>) { runBlocking { delay(2000) } }
Otro ejemplo:
suspend fun doWorkFor1Seconds(): String { delay(1000) return "doWorkFor1Seconds" }
suspend fun doWorkFor2Seconds(): String { delay(2000) return "doWorkFor2Seconds" }
// Serial execution private fun doWorksInSeries() { launch(CommonPool) { val one = doWorkFor1Seconds() val two = doWorkFor2Seconds() println("Kotlin One : " + one) println("Kotlin Two : " + two) } }
// The output is // Kotlin One : doWorkFor1Seconds // Kotlin Two : doWorkFor2Seconds
Ahora veamos el uso de async {}
// Parallel execution private fun doWorksInParallel() { val one = async(CommonPool) { doWorkFor1Seconds() } val two = async(CommonPool) { doWorkFor2Seconds() } launch(CommonPool) { val combined = one.await() + "_" + two.await() println("Kotlin Combined : " + combined) } } // The output is // Kotlin Combined : doWorkFor1Seconds_doWorkFor2Seconds
Porque async{} usamos async{} , podemos llamar a await() para obtener el resultado.
Feliz aprendizaje;)