Me encantan las Corrutinas

Si hay algo de lo que he disfrutado desde hace mucho tiempo es del uso de las Corrutinas en Kotlin. Este año he decidido explotar su uso en el backend y no puedo estar más satisfecho: rapidez, sencillez y nuevas filosofías de programación fácilmente aplicables sin recurrir a otros recursos.

Corrutinas

Las corrutinas son una característica de Kotlin que viene a facilitar la programación asíncrona y la reactividad de una manera muy sencilla. Si vienes de otros lenguajes ya conoces async/await de JavaScript o C# o los observables de RxJava y compañía. Las corrutinas permiten escribir código asíncrono de forma secuencial, ocultando la complejidad subyacente de las callbacks y el manejo de hilos.

La diferencia principal es que el hilo no se bloquea, sino que se suspende mientras espera el resultado de una operación. Esto es fundamental en aplicaciones donde la concurrencia y el rendimiento son importantes, como en aplicaciones móviles o servicios web.

suspend fun ejemplo() {
    val resultado = operacionAsincrona()
    println(resultado)
}

Scope y Context

Las corrutinas necesitan un contexto y un alcance (scope) para ejecutarse. El contexto incluye el Dispatcher que define en qué hilo se ejecuta la corrutina (Main, IO, etc.) y el alcance define el tiempo de vida de la corrutina.

val scope = CoroutineScope(Dispatchers.Main + SupervisorJob())

Funciones suspend

Las funciones suspend son funciones que pueden ser pausadas y reanudadas. Solo pueden ser llamadas desde una corrutina u otra función suspend.

suspend fun getDatos(): Datos {
    return withContext(Dispatchers.IO) {
        baseDeDatos.obtener()
    }
}

async/await

Permite ejecutar varias operaciones en paralelo y esperar sus resultados.

val dato1 = async { getDatos1() }
val dato2 = async { getDatos2() }
println(dato1.await() + dato2.await())

Flows

Los Flows son secuencias asíncronas que pueden emitir múltiples valores, perfectos para el manejo de streams de datos.

fun getDatosFlow(): Flow<Datos> = flow {
    while (true) {
        emit(getDatos())
        delay(1000)
    }
}

Channels

Los channels permiten comunicación entre corrutinas de forma segura.

val channel = Channel<String>()
channel.send("mensaje")
val mensaje = channel.receive()

Las corrutinas han revolucionado la forma de programar en Kotlin, facilitando el manejo de operaciones asíncronas de forma clara y eficiente.