Planificador de tareas Kotlin: descripción general y…

Planificador de tareas Kotlin: descripción general completa y ejemplos de uso

El planificador de tareas es un componente importante de cualquier aplicación, que permite ejecutar código según un horario, con retraso o periódicamente. En el lenguaje Kotlin, especialmente al desarrollar en JVM, Android o proyectos multiplataforma, existen varias formas de implementar planificadores. En este artículo, analizaremos en detalle las herramientas principales: las capacidades integradas de kotlinx-coroutines-core, java.util.Timer, java.util.concurrent.Executors, así como la biblioteca especializada korGE para juegos y animaciones.

1. Planificador de tareas basado en corrutinas (kotlinx-coroutines-core)

Esta es la forma más moderna y recomendada para aplicaciones Kotlin. La biblioteca kotlinx-coroutines-core proporciona herramientas flexibles para la ejecución retrasada y periódica de código.

Instalación

Agregue la dependencia en build.gradle.kts:

dependencies {    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.8.0")}

Tarea retrasada (delay)

Retraso simple de ejecución usando delay dentro de una corrutina:

import kotlinx.coroutines.*

fun main() = runBlocking {    println("Inicio: ${System.currentTimeMillis()}")    delay(2000) // retraso de 2 segundos    println("Ejecutado después de 2 segundos: ${System.currentTimeMillis()}")}

Tarea periódica mediante launch y while

import kotlinx.coroutines.*

fun main() = runBlocking {    val job = launch {        repeat(5) { i ->            println("Tarea #${i + 1}: ${System.currentTimeMillis()}")            delay(1000)        }    }    job.join()}

Uso de Dispatchers para hilos en segundo plano

El planificador puede funcionar en diferentes despachadores, por ejemplo Dispatchers.IO para operaciones de red:

import kotlinx.coroutines.*

fun main() = runBlocking {    val job = launch(Dispatchers.IO) {        println("Ejecutándose en el hilo: ${Thread.currentThread().name}")        delay(3000)        println("Completado")    }    job.join()}

2. Planificador clásico: java.util.Timer

Si trabaja en un entorno JVM y desea utilizar el enfoque tradicional, Timer y TimerTask son adecuados para escenarios simples.

import java.util.*

fun main() {    val timer = Timer()    val task = object : TimerTask() {        override fun run() {            println("Tarea periódica: ${System.currentTimeMillis()}")        }    }    // Iniciamos la tarea después de 1 segundo, luego cada 2 segundos    timer.schedule(task, 1000, 2000)

    // Detenemos después de 10 segundos    Thread.sleep(10000)    timer.cancel()}

Tarea única retrasada

val timer = Timer()timer.schedule(object : TimerTask() {    override fun run() {        println("Tarea única después de 3 segundos")    }}, 3000)

3. Planificador con Executors (ScheduledExecutorService)

Una herramienta más potente y flexible de Java Concurrency que se integra bien con Kotlin.

import java.util.concurrent.*

fun main() {    val scheduler = Executors.newScheduledThreadPool(2)

    // Tarea con retraso    scheduler.schedule({        println("Tarea retrasada: ${System.currentTimeMillis()}")    }, 2, TimeUnit.SECONDS)

    // Tarea periódica con retraso fijo    val periodicTask = scheduler.scheduleWithFixedDelay({        println("Tarea periódica: ${System.currentTimeMillis()}")    }, 1, 3, TimeUnit.SECONDS)

    // Detención después de 15 segundos    Thread.sleep(15000)    periodicTask.cancel(false)    scheduler.shutdown()}