Files d'attente de tâches pour Kotlin : Coroutines et…

Files d'attente de tâches pour Kotlin : Coroutines et KJobQueue

Dans le développement moderne avec Kotlin — que ce soit pour une application Android, un backend avec Ktor ou un microservice — il est souvent nécessaire d'exécuter des tâches en arrière-plan de manière asynchrone et dans le bon ordre. Une file d'attente de tâches (job queue) permet de gérer ces opérations : téléchargement de fichiers, synchronisation de données, envoi d'analyses, traitement d'images. Dans cet article, nous allons voir comment construire une file d'attente de tâches avec les coroutines Kotlin, et découvrir la bibliothèque KJobQueue, une solution légère pour la gestion avancée des tâches.

Pourquoi une file d'attente de tâches ?

Les principaux problèmes résolus par une file d'attente de tâches :

Ordre d'exécution — les tâches ne doivent pas entrer en conflit pour les ressources.
Limitation du parallélisme — par exemple, pas plus de 3 téléchargements simultanés.
Gestion des erreurs et tentatives — en cas d'échec, une tâche peut être relancée.
Priorités — les tâches urgentes sont exécutées en premier.
Résistance au redémarrage — la file peut conserver son état.

File d'attente simple avec les coroutines (Channel)

La façon la plus simple d'implémenter une file d'attente est d'utiliser Channel et une coroutine de traitement. Exemple :

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

data class Task(val id: Int, val payload: String)

suspend fun processTask(task: Task) {    println("Traitement de la tâche ${task.id} : ${task.payload}")    delay(500) // simulation de travail}

fun main() = runBlocking {    val taskChannel = Channel<Task>(capacity = 10)

    // Lancement du worker    val worker = launch {        for (task in taskChannel) {            processTask(task)        }    }

    // Ajout de tâches    launch {        repeat(5) { i ->            taskChannel.send(Task(i, "Données $i"))        }        taskChannel.close()    }

    worker.join()}

Cette approche convient pour des scénarios simples, mais ne prend pas en charge les priorités, les tentatives et la persistance de l'état.

KJobQueue — une bibliothèque pour une file d'attente avancée

KJobQueue (disponible sur GitHub) est une bibliothèque légère pour Kotlin, construite sur les coroutines. Elle offre :

File d'attente avec priorités (basée sur Comparable).
Limitation du parallélisme (nombre de tâches exécutées simultanément).
Tentatives automatiques avec délai.
Prise en charge de l'annulation et de l'arrêt.
Dispatcher configurable (pool de threads).

Installation

Ajoutez dans build.gradle.kts :

dependencies {    implementation("io.github.kjobqueue:kjobqueue-core:1.0.0")}

Exemple d'utilisation de KJobQueue

import io.github.kjobqueue.*import kotlinx.coroutines.*import kotlin.random.Random

class DownloadJob(val url: String, override val priority: Int = 0) : PriorityJob {    override suspend fun execute() {        println("Téléchargement de $url (priorité $priority)")        delay(1000)        if (Random.nextBoolean()) throw RuntimeException("Erreur réseau")    }}

fun main() = runBlocking {    val queue = JobQueue(        maxConcurrent = 2,          // maximum 2 tâches simultanées        retryDelayMs = 500L,        // délai avant une nouvelle tentative        maxRetries = 3              // maximum 3 tentatives    )

    queue.add(DownloadJob("https://example.com/file1", priority = 5))    queue.add(DownloadJob("https://example.com/file2", priority = 1))    queue.add(DownloadJob("https://example.com/file3", priority = 10))

    delay(5000) // laisser le temps d'exécution    queue.shutdown()}