Coroutines con Kotlin — Introducción

Esta serie de artículos ofrece una introducción al increíble mundo de las coroutines con Kotlin. Si te gusta la programación y no estás conforme con lo complicado al trabajar con concurrencia, la información que te entregará esta serie de artículos hará que dejes de pelear con ese código verboso difícil de leer y entender cuando trabajas con hilos, callbacks y sincronización. Es decir, todo lo que implica y se complica cuando se trabaja con concurrencia.

Puedes ir a cualquier artículo de esta serie haciendo clic en alguno de los siguientes enlaces:

Coroutines con Kotlin

1. Introducción
2. Constructores de Coroutines
3. CoroutineScope y CoroutineContext
4. CoroutineContext: I — El elemento ‘Job’
5. CoroutineContext: II — El elemento ‘ContinuationInterceptor’
6. CoroutineContext: III — El elemento ‘CoroutineExceptionHandler’
7. CoroutineContext: IV — El elemento ‘CoroutineName’
8. SupervisorJob y supervisorScope
9. Funciones suspendibles
10. Construcción de Coroutines con GlobalScope
11. Channels: I — Comunicación entre coroutines
12. Channels: II — El constructor ‘produce’
13. Estados mutables compartidos: I — Técnicas
14. Estados mutables compartidos: II — El constructor ‘actor’
15. Flow: I — Estructura, dinámica, restricciones y operadores
16. Flow: II — Operadores personalizados y manejo de excepciones
17. Pruebas unitarias de coroutines y de funciones suspendibles
18. Anexo: Cancelación cooperativa, Coroutines perezosas y Canales de difusión

¿Qué son las coroutines?

Según la propia documentación oficial, una coroutine es en sí misma un hilo liviano. Es decir, se vale de hilos o pool de hilos para ejecutar código de manera concurrente y de forma muy eficiente optimizando el uso de recursos.

¿Qué ventajas ofrecen las coroutines?

Desde el punto de vista del desarrollador, las coroutines permiten implementar código asincrónico con un estilo idéntico al código sincrónico. Gracias a que su mecanismo interno hace uso de la interfaz Continuation cada vez que se suspende un hilo, su implementación se vuelve más legible al no ser nosotros los que tenemos que lidiar con el uso de callbacks o implementaciones de interfaces con clases anónimas.

Desde el punto de vista del rendimiento, las coroutines permiten la ejecución de miles y hasta millones de subprocesos concurrentemente con un uso de recursos eficiente haciendo más robusta la aplicación al ser más difícil de alcanzar un error que indique falta de memoria.

Desde el punto de vista de la implementación, las coroutines permiten una manipulación sencilla de los hilos de ejecución valiéndose de los Dispatchers, los cuales nos permiten determinar explícitamente el hilo que deseamos que ejecute un bloque específico de código.

Hilos vs Coroutines

Para tener una idea más clara de la diferencia entre un hilo común y una coroutine, comparemos los siguientes fragmentos de código que hacen exactamente lo mismo. El primero con el uso de hilos, el segundo con el uso de coroutines.

No te preocupes si no entiendes alguna parte del fragmento del código de la coroutine, conforme vayas avanzando en esta serie de artículos se te irán aclarando las dudas que tengas.

Primeramente definamos dos funciones comunes para imprimir mensajes en pantalla. Una de ellas nos servirá para identificar cuál es el hilo de ejecución:

• Hilos:

Si ejecutas el código directamente desde el recuadro anterior, es muy probable que te genere un error que indique falta de memoria. Si lo intentas ejecutar en tu propio entorno, por ejemplo en IntelliJ IDEA, el resultado de la ejecución del código anterior se debería parecer al siguiente:

• Coroutines:

A diferencia del ejemplo con hilos, si intentas ejecutar el código directamente desde el recuadro anterior, no tendrás ningún problema. El resultado se debería parecer al siguiente:

La primera gran diferencia que resulta muy notoria es el tiempo de ejecución. Mientras que con hilos comunes se tardó 4063 milisegundos, con coroutines tardó 1313 milisegundos. La segunda gran diferencia es que además de haberlo hecho casi tres veces más rápido, lo hizo todo con el mismo hilo.

Si juegas con el número de hilos y el número de coroutines y decides aumentarlos, notarás que la diferencia se acentúa exponencialmente. Ésta es la maravilla de las coroutines. Mientras que el código es prácticamente el mismo, la diferencia en rendimiento es abismal. Ésto implica que si deseamos empezar a usar coroutines, solo tenemos que hacer uno que otro cambio aquí y allá en nuestro código y nuestra aplicación ganaría muchísimo en rendimiento, traduciéndose en una mejor experiencia para el usuario.

En esta serie de artículos te enseñaré a usar las coroutines desde lo más básico para que aprendas, las entiendas y puedas implementarlas de manera correcta en tu código Kotlin.

¿Qué se necesita?

Asumiré que ya tienes algo de experiencia programando dado que el uso de hilos requiere poco más que un nivel básico en programación. Si estás aquí es porque manejas el concepto de concurrencia al menos en su nivel más básico.

He de suponer que ya tienes instalado el JDK, que al menos sabes programar en Java o algún otro lenguaje orientado a objetos y que conoces la sintaxis de Kotlin. Si vienes de otro entorno será necesario que instales el JDK y que repases por tu cuenta lo más básico de Kotlin para que puedas leer los fragmentos de código aquí expuestos.

Para escribir código yo suelo utilizar IntelliJ IDEA, o en su defecto, Android Studio si estoy trabajando en una aplicación para Android. Aunque ninguno de estos IDE es necesario, yo recomiendo su uso. Puedes usar el IDE de tu preferencia o incluso el bloc de notas y la línea de comandos.

Por último, para hacer uso de las coroutines, es necesario que incluyas en tu proyecto Kotlin la siguiente librería:

org.jetbrains.kotlinx:kotlinx-coroutines-core:{version}

Asegúrate de utilizar la última versión estable visitando el siguiente enlace https://mvnrepository.com/artifact/org.jetbrains.kotlinx/kotlinx-coroutines-core. Al momento de escribir este documento, la última versión disponible y que yo estoy utilizando es la siguiente:

org.jetbrains.kotlinx:kotlinx-coroutines-core:1.3.2

Por el momento eso es todo. Aunque es muy probable que ya lo hayas notado, solo me queda decirte que los fragmentos de código que expondré estarán escritos en Inglés.

Si todavía escribes código exclusivamente en Español, te sugiero empezar desde ya a escribir todo en Inglés. No me malinterpretes, yo amo el Español, es mi lengua nativa pero el Inglés te abre muchas más puertas en este mundo del desarrollo de software y prácticamente en cualquier área de la vida. ¡Vamos, no te preocupes!, son solamente nombres de variables, nombres de métodos y Strings en Inglés, más allá de eso no habrá otra cosa.

Continúa en el siguiente enlace con Constructores de Coroutines.

• Puedes acceder a la documentación oficial de las coroutines en el siguiente enlace: https://kotlinlang.org/docs/reference/coroutines-overview.html