Cómo usar coroutines en Kotlin
Las coroutines en Kotlin son una herramienta poderosa para manejar la programación asíncrona sin bloquear el hilo principal. A diferencia de los hilos tradicionales, las coroutines son ligeras y pueden suspender su ejecución sin bloquear, permitiendo que el hilo continúe procesando otras tareas. Esto mejora la eficiencia en el manejo de tareas de entrada/salida o cualquier operación que pueda demorarse.
Sintaxis básica de una coroutine
Para utilizar coroutines en Kotlin, debes incluir las siguientes dependencias en tu proyecto:
implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.5.2"
Una coroutine se define utilizando las funciones launch o async, que deben ser ejecutadas dentro de un contexto de coroutine, como runBlocking, GlobalScope, o un CoroutineScope personalizado.
Ejemplo básico de coroutine con launch
import kotlinx.coroutines.*
fun main() = runBlocking {
launch {
delay(1000L)
println("Mundo!")
}
println("Hola,")
}En este ejemplo:
-
runBlocking: crea un bloque de código donde se ejecutan las coroutines. -
launch: lanza una nueva coroutine de forma asíncrona. -
delay: suspende la coroutine por 1000 ms sin bloquear el hilo principal.
Salida:
Hola,
Mundo!
El hilo principal no se bloquea mientras la coroutine se suspende con delay, permitiendo que el programa continúe ejecutándose.
Uso de async y await para resultados concurrentes
Si necesitas que una coroutine devuelva un resultado, puedes usar async y recoger el resultado con await.
import kotlinx.coroutines.*
fun main() = runBlocking {
val resultado1 = async { calcularAlgoLento(10) }
val resultado2 = async { calcularAlgoLento(20) }
println("El resultado es ${resultado1.await() + resultado2.await()}")
}
suspend fun calcularAlgoLento(valor: Int): Int {
delay(1000L)
return valor * 2
}-
async: permite iniciar coroutines que retornan un valor. -
await: espera el resultado de la coroutine de forma no bloqueante.
Ejemplo de coroutine con withContext
Si necesitas cambiar el contexto de una coroutine (por ejemplo, ejecutar una tarea en un hilo de fondo), puedes usar withContext para hacer la transición sin bloquear el hilo principal.
import kotlinx.coroutines.*
fun main() = runBlocking {
val resultado = withContext(Dispatchers.Default) {
calcularAlgoLento(5)
}
println("Resultado: $resultado")
}-
Dispatchers.Default: usa un pool de hilos predeterminado para ejecutar tareas en paralelo.
Ventajas de las coroutines
- Ligereza: Las coroutines son mucho más ligeras que los hilos, lo que permite lanzar miles de ellas sin un impacto significativo en el rendimiento.
- Suspensión sin bloqueo: Las operaciones de larga duración, como las solicitudes de red o las operaciones de entrada/salida, pueden suspenderse sin bloquear el hilo.
- Facilidad de uso: Kotlin proporciona una sintaxis clara y herramientas poderosas para manejar tareas asíncronas, haciéndolas más fáciles de implementar y mantener.
Referencia oficial
Para obtener más información sobre el uso de coroutines en Kotlin, visita la documentación oficial de Kotlin sobre coroutines.
Jorge García
Fullstack developer