Colas de tareas en Kotlin: Coroutines, Flow y bibliotecas para procesamiento en segundo plano

Colas de tareas para Kotlin: procesamiento eficiente en segundo plano

En el desarrollo moderno con Kotlin (especialmente para Android, backend con Ktor o Spring), a menudo es necesario organizar la ejecución de tareas en segundo plano sin bloquear el hilo principal. Para esto se utilizan colas de tareas: mecanismos que permiten poner operaciones en cola y ejecutarlas de forma secuencial o concurrente. En Kotlin, el soporte integrado de corrutinas (coroutines) proporciona herramientas potentes para esto: Channel, Flow y despachadores. Además, existen bibliotecas especializadas como Kjob y Kotlinx-coroutines que simplifican la gestión de tareas.

En este artículo analizaremos los enfoques principales para crear colas de tareas en Kotlin, sus ventajas y proporcionaremos ejemplos prácticos de código.

1. Herramientas integradas de Kotlin: Channel y Flow

Channel es un primitivo para transferir datos entre corrutinas, que funciona según el principio de "productor-consumidor". Es ideal para crear una cola de tareas simple.

import kotlinx.coroutines.*import kotlinx.coroutines.channels.*

suspend fun main() = coroutineScope {    val channel = Channel<String>(capacity = 10) // canal con búfer

    // Productor (colocador de tareas)    launch {        for (i in 1..5) {            val task = "Tarea nº$i"            println("Colocada: $task")            channel.send(task)            delay(100)        }        channel.close() // cerramos el canal después de enviar todas las tareas    }

    // Consumidor (procesador)    launch {        for (task in channel) { // recibimos automáticamente mientras el canal esté abierto            println("Procesando: $task")            delay(300) // simulación de trabajo        }        println("Todas las tareas procesadas")    }}

Flow es un flujo de datos asíncrono frío que puede usarse para crear una cola con capacidad de cancelación y transformación.

import kotlinx.coroutines.*import kotlinx.coroutines.flow.*

fun taskQueue(): Flow<String> = flow {    for (i in 1..5) {        emit("Tarea nº$i")        delay(200)    }}

suspend fun main() = coroutineScope {    taskQueue()        .map { task ->            "Procesada: $task"        }        .collect { result ->            println(result)        }}

2. Kotlinx-coroutines: Dispatchers y Job

La biblioteca kotlinx-coroutines (parte del paquete oficial de Kotlin) proporciona despachadores (Dispatchers.Default, Dispatchers.IO) para ejecutar tareas en un grupo de hilos. Con Job y SupervisorJob se puede gestionar el ciclo de vida de la cola.

import kotlinx.coroutines.*

suspend fun main() = coroutineScope {    val job = SupervisorJob()    val scope = CoroutineScope(Dispatchers.IO + job)

    // Agregamos tareas a la cola    scope.launch {        repeat(10) { i ->            delay(100)            println("Tarea $i ejecutándose en ${Thread.currentThread().name}")        }    }

    // Esperamos a que termine    delay(2000)    println("El hilo principal continúa trabajando")}

Para escenarios más complejos (por ejemplo, reintentos, retrasos entre tareas) se puede usar kotlinx-coroutines-core con las funciones retry o withTimeout.

3. Biblioteca especializada: Kjob

Kjob es una biblioteca ligera para gestionar tareas en segundo plano en Kotlin, que admite colas, retrasos, reintentos y monitoreo. Funciona sobre corrutinas y no requiere dependencias externas.

Instalación mediante Gradle:

implementation("io.github.oshai:kjob:2.2.0")

Ejemplo de uso:

import io.