Asynchrone Programmierung in Kotlin: Vollständiger Leitfaden für Anfänger

Online Python-Trainer für Anfänger

Lernen Sie Python einfach ohne theoretische Überlastung. Lösen Sie praktische Aufgaben mit automatischer Überprüfung und schreiben Sie Code direkt im Browser.

Kurs starten

Einführung in die asynchrone Programmierung in Kotlin

Moderne Anwendungen erfordern hohe Leistung und Reaktionsfähigkeit. Asynchrone Programmierung ermöglicht die Ausführung langwieriger Operationen (Netzwerkanfragen, Dateilesen, Datenbankarbeit) ohne Blockierung des Hauptausführungsstrangs. In Kotlin wird dafür ein leistungsstarker und eleganter Mechanismus verwendet – Koroutinen (coroutines).

Im Gegensatz zu traditionellen Threads sind Koroutinen leichtgewichtig, werden auf Sprachebene verwaltet und benötigen keine großen Systemressourcen. Dies macht sie zu einem idealen Werkzeug zum Schreiben von asynchronem Code, der leicht zu lesen und zu warten ist. In diesem Leitfaden werden wir die grundlegenden Konzepte der asynchronen Programmierung in Kotlin von Grund auf behandeln.

1. Grundlagen der Koroutinen: Was ist das und wie funktioniert es?

Eine Koroutine ist eine Instanz einer unterbrechbaren (suspendable) Berechnungsoperation. Sie kann an einer Stelle im Code angehalten und an einer anderen wieder aufgenommen werden, ohne dabei den Thread zu blockieren. Für die Arbeit mit Koroutinen muss die Bibliothek kotlinx.coroutines eingebunden werden.

Abhängigkeit einbinden

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

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

Erste Koroutine

Zum Starten einer Koroutine wird der Builder launch verwendet. Er startet eine neue Koroutine im Hintergrund.

import kotlinx.coroutines.*

fun main() = runBlocking { // runBlocking blockiert den Hauptthread, um auf Koroutinen zu warten    println("Start: ${Thread.currentThread().name}")

    launch { // Start einer neuen Koroutine        delay(1000L) // Anhalten für 1 Sekunde (blockiert den Thread nicht!)        println("Koroutine: ${Thread.currentThread().name}")    }

    println("Ende: ${Thread.currentThread().name}")}

Ausgabe:

Start: mainEnde: mainKoroutine: main

Beachten Sie: delay ist eine suspend-Funktion, die die Koroutine anhält, aber den Thread nicht blockiert. Während die Koroutine "schläft", kann der Thread anderen Code ausführen.

2. Suspend-Funktionen: Bausteine der Asynchronität

Eine Suspend-Funktion ist eine Funktion, die angehalten und später wieder fortgesetzt werden kann. Solche Funktionen können nur aus anderen suspend-Funktionen oder aus einer Koroutine heraus aufgerufen werden. Sie werden mit dem Schlüsselwort suspend gekennzeichnet.

Beispiel einer suspend-Funktion

import kotlinx.coroutines.*

suspend fun fetchData(): String {    delay(2000L) // Simulation einer langen Netzwerkanfrage    return "Daten empfangen"}

fun main() = runBlocking {    println("Daten anfragen...")    val result = fetchData() // Aufruf einer suspend-Funktion aus einer Koroutine    println(result)}

Parallele Ausführung mit async/await

Wenn mehrere Aufgaben parallel ausgeführt werden sollen, verwenden Sie den Builder async. Er gibt ein Deferred zurück – ein Objekt, das das zukünftige Ergebnis speichert. Das Ergebnis kann mit await() abgerufen werden.

import kotlinx.coroutines.*

suspend fun loadUser(): String {    delay(1000L)    return "Benutzer: Ivan"}

suspend fun loadPosts(): String {    delay(1500L)    return "Beiträge: Nachrichten, Artikel"}

fun main() = runBlocking {    val time = measureTimeMillis {        val userDeferred = async { loadUser() }        val postsDeferred = async { loadPosts() }

        println(userDeferred.await())        println(postsDeferred.await())    }    println("Gesamtzeit: $time ms") // ~1500 ms (maximale Zeit von beiden)}

Ohne async würden die Aufgaben sequenziell ausgeführt werden und ~2500 ms dauern. Die parallele Ausführung hat die Zeit auf ~1500 ms reduziert.