Planificador de tareas Kotlin: kotlinx.coroutines y bibliotecas para tareas en segundo plano

Planificador de tareas en Kotlin: desde corrutinas hasta soluciones empresariales

Kotlin es un lenguaje de programación moderno que se utiliza activamente para crear aplicaciones de servidor, móviles y de escritorio. Una de las necesidades clave en estos proyectos es la ejecución de tareas programadas o en segundo plano. En este artículo, analizaremos qué herramientas y bibliotecas de Kotlin permiten organizar un planificador de tareas y proporcionaremos ejemplos prácticos de código.

Consideraremos tres enfoques principales:

• Herramientas integradas de Kotlin Coroutines (hilos ligeros)
• La biblioteca WorkManager para Android
• El clásico Quartz Scheduler con envoltorios de Kotlin

1. Planificador basado en kotlinx.coroutines

kotlinx.coroutines es la biblioteca estándar para programación asíncrona en Kotlin. Proporciona herramientas potentes para crear tareas retrasadas y periódicas.

Componentes principales:

• delay() — retraso en la ejecución de una corrutina
• launch y async — inicio de corrutinas
• CoroutineScope — gestión del ciclo de vida
• Dispatchers — selección del hilo de ejecución

Ejemplo de un planificador de tareas simple con repetición cada 5 segundos:

import kotlinx.coroutines.*

fun main() = runBlocking {    val job = launch {        repeat(10) { i ->            println("Tarea #$i ejecutada en ${System.currentTimeMillis()}")            delay(5000) // pausa de 5 segundos        }    }    job.join()    println("El planificador ha finalizado su trabajo")}

Para escenarios más complejos (cancelación de tareas, manejo de errores, limitación de frecuencia), use Job y SupervisorJob:

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

fun schedulePeriodicTask(intervalMs: Long, action: suspend () -> Unit): Job {    return scope.launch {        while (isActive) {            try {                action()            } catch (e: Exception) {                println("Error: ${e.message}")            }            delay(intervalMs)        }    }}

// Usoval task = schedulePeriodicTask(2000) {    println("Ejecutando tarea en segundo plano...")}

// Cancelar después de 10 segundosscope.launch {    delay(10000)    task.cancel()    println("Tarea cancelada")}

Ventajas: ligereza, soporte integrado para cancelación, integración con el ecosistema Kotlin. Desventajas: no es adecuado para aplicaciones Android que deben sobrevivir al reinicio del sistema.

2. WorkManager para Android (Kotlin)

WorkManager es una biblioteca de Google para ejecutar tareas retrasadas y en segundo plano en Android, incluso después de cerrar la aplicación o reiniciar el dispositivo. Funciona sobre corrutinas.

Pasos principales:

1. Crear una clase que herede de CoroutineWorker
2. Implementar el método doWork()
3. Configurar una WorkRequest (única o periódica)
4. Poner la tarea en cola a través de WorkManager

Ejemplo de una tarea periódica:

class MyPeriodicWorker(context: Context, params: WorkerParameters) :     CoroutineWorker(context, params) {

    override suspend fun doWork(): Result {        return try {            // Su tarea: sincronización, limpieza, etc.            println("Tarea periódica ejecutada en ${System.currentTimeMillis()}")            Result.success()        } catch (e: Exception) {            Result.retry()        }    }}

// Configuración e inicioval constraints = Constraints.Builder()    .setRequiredNetworkType(NetworkType.CONNECTED)    .build()

val periodicRequest = PeriodicWorkRequestBuilder&