Colas de tareas en Kotlin: Coroutines, KJob y patrones avanzados

Colas de tareas para Kotlin: desde Coroutines hasta soluciones avanzadas

En el desarrollo moderno con Kotlin, las colas de tareas (task queues) juegan un papel clave para construir aplicaciones receptivas y escalables. Ya sea que esté creando una aplicación de servidor con Ktor, una aplicación móvil para Android o una solución de escritorio con Compose, comprender los mecanismos de procesamiento asíncrono de tareas es una habilidad obligatoria. En este artículo, analizaremos las principales herramientas, bibliotecas y patrones para trabajar con colas de tareas en Kotlin.

1. Herramientas integradas: Kotlin Coroutines

Lo primero por donde empezar son las Kotlin Coroutines. Proporcionan hilos ligeros (coroutines) y colas integradas a través de canales (Channel) y despachadores (Dispatcher).

Ejemplo básico de una cola con canales:

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

fun main() = runBlocking {    val channel = Channel<String>(capacity = 10) // cola con búfer

    // Productor    launch {        repeat(5) {            channel.send("Tarea nº${it + 1}")            delay(100)        }        channel.close()    }

    // Consumidor    launch {        for (task in channel) {            println("Procesando: $task")            delay(200)        }    }}

Este patrón permite crear colas simples con uno o varios consumidores. Sin embargo, para escenarios complejos (prioridades, reinicio de tareas fallidas, monitoreo) se necesitan bibliotecas especializadas.

2. KJob — biblioteca para tareas en segundo plano

KJob (Kotlin Job Queue) es una biblioteca ligera para gestionar tareas en segundo plano con soporte para prioridades, reintentos y seguimiento de estado. Está construida sobre coroutines y es ideal para aplicaciones Android y de servidor.

Instalación (Gradle):

dependencies {    implementation("com.github.kjob:kjob:0.6.0")}

Ejemplo de uso:

import com.github.kjob.*import kotlinx.coroutines.runBlocking

fun main() = runBlocking {    val queue = KJobQueue()

    // Agregamos tareas con prioridad    queue.add(KJob("alta-prioridad") {        println("Ejecutando tarea importante")    }.priority(10))

    queue.add(KJob("baja-prioridad") {        println("Ejecutando tarea no importante")    }.priority(1))

    // Iniciamos el procesamiento    queue.processAll()}

KJob soporta:

• Prioridades — las tareas con alta prioridad se ejecutan primero.
• Reintentos — reinicio automático en caso de errores.
• Timeouts — límite de tiempo de ejecución.
• Eventos del ciclo de vida — es posible suscribirse al inicio, finalización y error.

3. KQueue — colas distribuidas

Si necesita una cola de tareas distribuida (por ejemplo, para microservicios), considere KQueue. Es una biblioteca para trabajar con colas a través de Redis o Kafka, escrita en Kotlin puro.

Ejemplo con Redis:

import com.kqueue.*import io.lettuce.core.RedisClient

fun main() {    val client = RedisClient.create("redis://localhost")    val queue = KQueue(client)

    // Enviamos una tarea    queue.push("pedidos", "Procesar pedido #123")

    // Consumimos tareas    queue.poll("pedidos") { task ->        println("Tarea recibida: ${task.body}")        // Procesamiento...        task.ack() // confirmación de ejecución    }}

KQueue garantiza:

• Entrega garantizada (al menos una vez).
• Balanceo de carga entre procesos trabajadores.
• Soporte para tareas programadas (scheduled tasks).
• Monitoreo a través de métricas de Prometheus.

4. Avanzadas