Kotlin Aufgabenplaner: Überblick und Beispiele

Kotlin Aufgabenplaner: Vollständiger Überblick und Anwendungsbeispiele

Ein Aufgabenplaner ist eine wichtige Komponente jeder Anwendung, die es ermöglicht, Code zeitgesteuert, verzögert oder periodisch auszuführen. In der Sprache Kotlin, insbesondere bei der Entwicklung auf JVM, Android oder in plattformübergreifenden Projekten, gibt es mehrere Möglichkeiten zur Implementierung von Planern. In diesem Artikel betrachten wir die wichtigsten Werkzeuge im Detail: die integrierten Funktionen von kotlinx-coroutines-core, java.util.Timer, java.util.concurrent.Executors sowie die spezialisierte Bibliothek korGE für Spiele und Animationen.

1. Aufgabenplaner auf Basis von Coroutinen (kotlinx-coroutines-core)

Dies ist die modernste und empfohlene Methode für Kotlin-Anwendungen. Die Bibliothek kotlinx-coroutines-core bietet flexible Mittel für die verzögerte und periodische Ausführung von Code.

Installation

Fügen Sie die Abhängigkeit in build.gradle.kts hinzu:

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

Verzögerte Aufgabe (delay)

Eine einfache Ausführungsverzögerung mit delay innerhalb einer Coroutine:

import kotlinx.coroutines.*

fun main() = runBlocking {    println("Start: ${System.currentTimeMillis()}")    delay(2000) // Verzögerung 2 Sekunden    println("Ausgeführt nach 2 Sekunden: ${System.currentTimeMillis()}")}

Periodische Aufgabe mit launch und while

import kotlinx.coroutines.*

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

Verwendung von Dispatchers für Hintergrund-Threads

Der Planer kann auf verschiedenen Dispatchern arbeiten, z.B. Dispatchers.IO für Netzwerkoperationen:

import kotlinx.coroutines.*

fun main() = runBlocking {    val job = launch(Dispatchers.IO) {        println("Wird im Thread ausgeführt: ${Thread.currentThread().name}")        delay(3000)        println("Abgeschlossen")    }    job.join()}

2. Klassischer Planer: java.util.Timer

Wenn Sie in einer JVM-Umgebung arbeiten und einen traditionellen Ansatz verwenden möchten, eignen sich Timer und TimerTask für einfache Szenarien.

import java.util.*

fun main() {    val timer = Timer()    val task = object : TimerTask() {        override fun run() {            println("Periodische Aufgabe: ${System.currentTimeMillis()}")        }    }    // Aufgabe starten nach 1 Sekunde, dann alle 2 Sekunden    timer.schedule(task, 1000, 2000)

    // Nach 10 Sekunden stoppen    Thread.sleep(10000)    timer.cancel()}

Einmalige verzögerte Aufgabe

val timer = Timer()timer.schedule(object : TimerTask() {    override fun run() {        println("Einmalige Aufgabe nach 3 Sekunden")    }}, 3000)

3. Planer mit Executors (ScheduledExecutorService)

Ein leistungsfähigeres und flexibleres Werkzeug aus Java Concurrency, das sich gut in Kotlin integrieren lässt.

import java.util.concurrent.*

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

    // Aufgabe mit Verzögerung    scheduler.schedule({        println("Verzögerte Aufgabe: ${System.currentTimeMillis()}")    }, 2, TimeUnit.SECONDS)

    // Periodische Aufgabe mit fester Verzögerung    val periodicTask = scheduler.scheduleWithFixedDelay({        println("Periodische Aufgabe: ${System.currentTimeMillis()}")    }, 1, 3, TimeUnit.SECONDS)

    // Stopp nach 15 Sekunden    Thread.sleep(15000)    periodicTask.cancel(false)    scheduler.shutdown()}