Planificateur de tâches Kotlin : kotlinx.coroutines et bibliothèques pour tâches en arrière-plan

Planificateur de tâches en Kotlin : des coroutines aux solutions d'entreprise

Kotlin est un langage de programmation moderne activement utilisé pour créer des applications serveur, mobiles et de bureau. L'un des besoins clés dans ces projets est l'exécution de tâches selon un calendrier ou en arrière-plan. Dans cet article, nous allons examiner quels outils et bibliothèques Kotlin permettent d'organiser un planificateur de tâches, et fournir des exemples pratiques de code.

Nous aborderons trois approches principales :

• Les outils intégrés de Kotlin Coroutines (threads légers)
• La bibliothèque WorkManager pour Android
• Le classique Quartz Scheduler avec des wrappers Kotlin

1. Planificateur basé sur kotlinx.coroutines

kotlinx.coroutines est la bibliothèque standard pour la programmation asynchrone en Kotlin. Elle fournit des outils puissants pour créer des tâches différées et périodiques.

Composants principaux :

• delay() — délai d'exécution d'une coroutine
• launch et async — lancement de coroutines
• CoroutineScope — gestion du cycle de vie
• Dispatchers — choix du thread d'exécution

Exemple d'un planificateur de tâches simple avec répétition toutes les 5 secondes :

import kotlinx.coroutines.*

fun main() = runBlocking {    val job = launch {        repeat(10) { i ->            println("Tâche #$i exécutée à ${System.currentTimeMillis()}")            delay(5000) // pause de 5 secondes        }    }    job.join()    println("Le planificateur a terminé son travail")}

Pour des scénarios plus complexes (annulation de tâches, gestion des erreurs, limitation de fréquence), utilisez Job et 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("Erreur : ${e.message}")            }            delay(intervalMs)        }    }}

// Utilisationval task = schedulePeriodicTask(2000) {    println("Tâche en arrière-plan en cours d'exécution...")}

// Annulation après 10 secondesscope.launch {    delay(10000)    task.cancel()    println("Tâche annulée")}

Avantages : légèreté, prise en charge intégrée de l'annulation, intégration avec l'écosystème Kotlin. Inconvénients : ne convient pas aux applications Android qui doivent survivre au redémarrage du système.

2. WorkManager pour Android (Kotlin)

WorkManager est une bibliothèque de Google pour exécuter des tâches différées et en arrière-plan sur Android, même après la fermeture de l'application ou le redémarrage de l'appareil. Elle fonctionne au-dessus des coroutines.

Étapes principales :

1. Créer une classe héritant de CoroutineWorker
2. Implémenter la méthode doWork()
3. Configurer une WorkRequest (unique ou périodique)
4. Mettre la tâche en file d'attente via WorkManager

Exemple de tâche périodique :

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

    override suspend fun doWork(): Result {        return try {            // Votre tâche : synchronisation, nettoyage, etc.            println("Tâche périodique exécutée à ${System.currentTimeMillis()}")            Result.success()        } catch (e: Exception) {            Result.retry()        }    }}

// Configuration et lancementval constraints = Constraints.Builder()    .setRequiredNetworkType(NetworkType.CONNECTED)    .build()

val periodicRequest = PeriodicWorkRequestBuilder&