Aufgabenwarteschlangen für Kotlin: Coroutines und…

Aufgabenwarteschlangen für Kotlin: Coroutines und KJobQueue

In der modernen Entwicklung mit Kotlin – sei es eine Android-App, ein Backend mit Ktor oder ein Mikroservice – entsteht oft die Notwendigkeit, Hintergrundaufgaben asynchron und in der richtigen Reihenfolge auszuführen. Eine Aufgabenwarteschlange (Job Queue) hilft, solche Operationen zu verwalten: Datei-Uploads, Datensynchronisation, das Senden von Analysedaten, Bildverarbeitung. In diesem Artikel schauen wir uns an, wie man eine Aufgabenwarteschlange mit Kotlin-Coroutines erstellt, und lernen die Bibliothek KJobQueue kennen – eine leichte Lösung für erweitertes Aufgabenmanagement.

Warum eine Aufgabenwarteschlange?

Die Hauptprobleme, die eine Aufgabenwarteschlange löst:

Ausführungsreihenfolge – Aufgaben sollen nicht um Ressourcen konkurrieren.
Parallelitätsbegrenzung – z. B. maximal 3 gleichzeitige Downloads.
Fehlerbehandlung und Wiederholungsversuche – bei einem Fehler kann eine Aufgabe neu gestartet werden.
Prioritäten – dringende Aufgaben werden zuerst ausgeführt.
Wiederaufnahmefähigkeit – die Warteschlange kann ihren Zustand speichern.

Einfache Warteschlange mit Coroutines (Channel)

Der einfachste Weg, eine Warteschlange zu implementieren, ist die Verwendung von Channel und einer Coroutine als Bearbeiter. Beispiel:

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

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

suspend fun processTask(task: Task) {    println("Verarbeite Aufgabe ${task.id}: ${task.payload}")    delay(500) // simuliert Arbeit}

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

    // Worker starten    val worker = launch {        for (task in taskChannel) {            processTask(task)        }    }

    // Aufgaben hinzufügen    launch {        repeat(5) { i ->            taskChannel.send(Task(i, "Daten $i"))        }        taskChannel.close()    }

    worker.join()}

Dieser Ansatz eignet sich für einfache Szenarien, unterstützt aber keine Prioritäten, Wiederholungen oder Zustandsspeicherung.

KJobQueue – Bibliothek für erweiterte Warteschlangen

KJobQueue (verfügbar auf GitHub) ist eine leichte Bibliothek für Kotlin, die auf Coroutines aufbaut. Sie bietet:

Eine Warteschlange mit Prioritäten (basierend auf Comparable).
Parallelitätsbegrenzung (Anzahl der gleichzeitig ausgeführten Aufgaben).
Automatische Wiederholungsversuche mit Verzögerung.
Unterstützung für Abbruch und Stopp.
Anpassbaren Dispatcher (Thread-Pool).

Installation

Fügen Sie in build.gradle.kts hinzu:

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

Beispiel zur Verwendung von 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("Lade $url herunter (Priorität $priority)")        delay(1000)        if (Random.nextBoolean()) throw RuntimeException("Netzwerkfehler")    }}

fun main() = runBlocking {    val queue = JobQueue(        maxConcurrent = 2,          // maximal 2 Aufgaben gleichzeitig        retryDelayMs = 500L,        // Verzögerung vor Wiederholung        maxRetries = 3              // maximal 3 Wiederholungen    )

    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) // Zeit für die Ausführung geben    queue.shutdown()}