Planificateur de tâches Kotlin : aperçu et exemples |…

Planificateur de tâches Kotlin : aperçu complet et exemples d'utilisation

Le planificateur de tâches est un composant important de toute application, permettant d'exécuter du code selon un horaire, avec un délai ou de manière périodique. En langage Kotlin, notamment lors du développement sur JVM, Android ou de projets multiplateformes, il existe plusieurs façons d'implémenter des planificateurs. Dans cet article, nous examinerons en détail les outils principaux : les fonctionnalités intégrées de kotlinx-coroutines-core, java.util.Timer, java.util.concurrent.Executors, ainsi que la bibliothèque spécialisée korGE pour les jeux et les animations.

1. Planificateur de tâches basé sur les coroutines (kotlinx-coroutines-core)

C'est la méthode la plus moderne et recommandée pour les applications Kotlin. La bibliothèque kotlinx-coroutines-core fournit des outils flexibles pour l'exécution différée et périodique de code.

Installation

Ajoutez la dépendance dans build.gradle.kts :

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

Tâche différée (delay)

Un simple délai d'exécution avec delay à l'intérieur d'une coroutine :

import kotlinx.coroutines.*

fun main() = runBlocking {    println("Début : ${System.currentTimeMillis()}")    delay(2000) // délai de 2 secondes    println("Exécuté après 2 secondes : ${System.currentTimeMillis()}")}

Tâche périodique avec launch et while

import kotlinx.coroutines.*

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

Utilisation de Dispatchers pour les threads d'arrière-plan

Le planificateur peut fonctionner sur différents dispatchers, par exemple Dispatchers.IO pour les opérations réseau :

import kotlinx.coroutines.*

fun main() = runBlocking {    val job = launch(Dispatchers.IO) {        println("Exécuté dans le thread : ${Thread.currentThread().name}")        delay(3000)        println("Terminé")    }    job.join()}

2. Planificateur classique : java.util.Timer

Si vous travaillez dans un environnement JVM et souhaitez utiliser une approche traditionnelle, Timer et TimerTask conviennent pour des scénarios simples.

import java.util.*

fun main() {    val timer = Timer()    val task = object : TimerTask() {        override fun run() {            println("Tâche périodique : ${System.currentTimeMillis()}")        }    }    // Lance la tâche après 1 seconde, puis toutes les 2 secondes    timer.schedule(task, 1000, 2000)

    // Arrête après 10 secondes    Thread.sleep(10000)    timer.cancel()}

Tâche différée unique

val timer = Timer()timer.schedule(object : TimerTask() {    override fun run() {        println("Tâche unique après 3 secondes")    }}, 3000)

3. Planificateur avec Executors (ScheduledExecutorService)

Un outil plus puissant et flexible issu de Java Concurrency, qui s'intègre bien avec Kotlin.

import java.util.concurrent.*

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

    // Tâche avec délai    scheduler.schedule({        println("Tâche différée : ${System.currentTimeMillis()}")    }, 2, TimeUnit.SECONDS)

    // Tâche périodique avec délai fixe    val periodicTask = scheduler.scheduleWithFixedDelay({        println("Tâche périodique : ${System.currentTimeMillis()}")    }, 1, 3, TimeUnit.SECONDS)

    // Arrêt après 15 secondes    Thread.sleep(15000)    periodicTask.cancel(false)    scheduler.shutdown()}