Nebenläufigkeit und Multithreading in Kotlin: Coroutinen, Threads und praktische Beispiele

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

Parallelität und Multithreading in Kotlin: Von der Theorie zur Praxis

Moderne Anwendungen benötigen schnelle und reaktionsfähige Leistung. Ob es um das Laden von Daten aus dem Netzwerk, die Verarbeitung großer Arrays oder die Arbeit mit der Benutzeroberfläche geht — Parallelität und Multithreading sind unerlässlich. Kotlin, als moderne Sprache für JVM-, Android- und Multiplattform-Projekte, bietet flexible Werkzeuge zur Lösung dieser Probleme. In diesem Artikel werden wir die wichtigsten Ansätze aufschlüsseln: von klassischen Threads bis hin zu leichtgewichtigen Coroutinen, und zeigen, wie man effizienten Code schreibt.

1. Threads in Kotlin: Der klassische Ansatz

Threads sind ein grundlegender Mechanismus für die parallele Ausführung, der von Java übernommen wurde. In Kotlin können Sie Threads auf die gleiche Weise wie in Java erstellen, jedoch mit einer prägnanteren Syntax.

Ein einfaches Beispiel zum Starten eines Threads:

fun main() {    thread {        println("Thread gestartet: ${Thread.currentThread().name}")        Thread.sleep(1000)        println("Thread beendet")    }    println("Haupt-Thread: ${Thread.currentThread().name}")    Thread.sleep(2000)}

Allerdings haben Threads Nachteile: Sie sind speicherintensiv (jeder Thread verbraucht etwa 1 MB Speicher), ihre Anzahl ist begrenzt und der Kontextwechsel ist aufwendig. Für moderne Anwendungen mit Tausenden von parallelen Aufgaben sind Threads nicht die beste Wahl. Hier kommen Coroutinen zur Rettung.

2. Coroutinen: Eine leichtgewichtige Alternative

Coroutinen sind die Hauptfunktion von Kotlin für Parallelität. Sie arbeiten auf Basis von Threads, benötigen aber weniger Ressourcen. Ein einziger Thread kann Tausende von Coroutinen ausführen, diese anhalten und wieder fortsetzen, ohne zu blockieren.

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

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

Beispiel einer einfachen Coroutine:

import kotlinx.coroutines.*

fun main() = runBlocking {    launch {        delay(1000L) // Nicht-blockierende Verzögerung        println("Welt von der Coroutine!")    }    println("Hallo von der Haupt-Coroutine")    delay(2000L)}

Hier startet launch eine neue Coroutine, und delay pausiert sie, ohne den Thread zu blockieren. runBlocking wird verwendet, um den Haupt-Thread zu blockieren, bis alle Coroutinen abgeschlossen sind (normalerweise nur in main und Tests verwendet).

2.1. Suspend-Funktionen

Das Schlüsselwort suspend ermöglicht es, die Ausführung einer Funktion anzuhalten, ohne den Thread zu blockieren. Dies ist die Grundlage der asynchronen Programmierung in Kotlin.

suspend fun fetchUser(): String {    delay(500L) // Simuliert eine Netzwerkanfrage    return "User123"}

fun main() = runBlocking {    val user = fetchUser()    println("Benutzer erhalten: $user")}

2.2. Async und Deferred für parallele Aufgaben

Wenn Sie mehrere Aufgaben parallel ausführen und auf deren Ergebnisse warten müssen, verwenden Sie async und Deferred:

fun main() = runBlocking {    val time = measureTimeMillis {        val user = async { fetchUser() }        val profile = async { fetchProfile() }        println("Ergebnisse: ${user.await()}, ${profile.await()}")    }    println("Ausführungszeit: $time ms")}

suspend fun fetchUser(): String {    delay(500)    return "User"}

suspend fun fetchProfile(): String {    delay(500)    return "Profil"}

Beide Aufgaben werden parallel ausgeführt, was die Gesamtzeit reduziert.