Kotlin: Coroutinen, Android und Ökosystem

Kurz: Coroutinen sind leichtgewichtige Threads für asynchronen Code, der wie normaler sequenzieller Code aussieht. Sie gehören zur Bibliothek kotlinx.coroutines (nicht zur Standardbibliothek). In Gradle:

Teil des Kurses Kotlin

Kapitel 12 von 13 im Kurs Kotlin (Abschnitt „Ökosystem“). Mit Fortschritt, Quiz und Zertifikat auf der Lernseite.

Coroutinen

Coroutinen sind leichtgewichtige Threads für asynchronen Code, der wie normaler sequenzieller Code aussieht. Sie gehören zur Bibliothek kotlinx.coroutines (nicht zur Standardbibliothek). In Gradle:

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

Die Grundbegriffe:

Begriff	Bedeutung
suspend fun	Funktion, die pausieren kann, ohne einen Thread zu blockieren
launch { }	startet eine Coroutine, liefert einen Job
async { } / await()	startet und liefert später ein Ergebnis
runBlocking { }	Brücke von normalem zu suspendierendem Code (main, Tests)
delay(ms)	nicht blockierendes Warten
Dispatchers.IO / Default / Main	auf welchem Thread-Pool
coroutineScope, withContext	strukturierte Nebenläufigkeit, Kontextwechsel
Flow	asynchroner Strom von Werten

import kotlinx.coroutines.*
 
suspend fun holeNutzer(id: Int): String {
    delay(1000)                       // simuliert eine Netzwerkanfrage
    return "Nutzer $id"
}
 
fun main() = runBlocking {
    val start = System.currentTimeMillis()
 
    val a = async { holeNutzer(1) }
    val b = async { holeNutzer(2) }   // läuft parallel zu a
    println("${a.await()} und ${b.await()}")
    println("dauerte ~1 s, nicht 2 s")
 
    launch {
        delay(100)
        println("läuft im Hintergrund")
    }
    println("Hauptfluss geht weiter")
}

Ausgabe (gekürzt):

Nutzer 1 und Nutzer 2
dauerte ~1 s, nicht 2 s
Hauptfluss geht weiter
läuft im Hintergrund

Strukturierte Nebenläufigkeit: Coroutinen gehören zu einem Scope. Wird der Scope abgebrochen, werden alle Kind-Coroutinen beendet, es entstehen keine “vergessenen” Aufgaben.

Flow

fun zahlen(): Flow<Int> = flow {
    for (i in 1..3) {
        delay(100)
        emit(i)
    }
}
 
runBlocking {
    zahlen().map { it * it }.filter { it > 1 }.collect { println(it) }   // 4, 9
}

Android

Kotlin ist die offizielle Hauptsprache für Android. Eine moderne App besteht aus:

• Jetpack Compose: deklarative UI (Funktionen statt XML-Layouts)
• ViewModel + StateFlow: Zustand, der Konfigurationsänderungen überlebt
• Room (Datenbank), Retrofit/Ktor (Netzwerk), Hilt (Abhängigkeiten)
• Coroutinen für alles Asynchrone

@Composable
fun Zaehler() {
    var anzahl by remember { mutableStateOf(0) }
    Column {
        Text("Zähler: $anzahl")
        Button(onClick = { anzahl++ }) { Text("Plus") }
    }
}

Wird anzahl geändert, zeichnet Compose genau den betroffenen Teil neu.

Server mit Ktor

fun main() {
    embeddedServer(Netty, port = 8080) {
        routing {
            get("/") { call.respondText("Hallo von Ktor") }
            get("/nutzer/{id}") { call.respondText("Nutzer ${call.parameters["id"]}") }
        }
    }.start(wait = true)
}

Alternativen: Spring Boot (mit Kotlin-Unterstützung), Micronaut, Quarkus.

Kotlin Multiplatform

Mit Kotlin Multiplatform (KMP) teilst du Logik zwischen Android, iOS, Desktop und Web. Plattformspezifisches wird mit expect/actual getrennt. Compose Multiplatform teilt sogar die Oberfläche.

Build und Test

• Gradle mit Kotlin-DSL (build.gradle.kts) ist das Standard-Buildwerkzeug
• Tests mit JUnit 5, Kotest, Mocks mit MockK
• Formatierung: ktlint, detekt (statische Analyse)

class RechnerTest {
    @Test
    fun addition() {
        assertEquals(5, 2 + 3)
    }
}

Merke

• suspend, launch, async, runBlocking, delay sind die Grundbausteine der Coroutinen
• Strukturierte Nebenläufigkeit verhindert verlorene Aufgaben
• Android: Jetpack Compose, ViewModel, Room, Coroutinen
• Server: Ktor oder Spring Boot; Multiplatform teilt Code zwischen Plattformen
• Gradle (Kotlin-DSL) als Build-Werkzeug

Übungsaufgabe

Plane in Worten eine kleine App: Welche Daten kommen vom Netzwerk (Flow), wie wird der Zustand gehalten (ViewModel), wie wird er gezeigt (Compose)?

Quiz zur Selbstkontrolle

Wofür steht suspend?

• Die Funktion kann pausieren, ohne den Thread zu blockieren (richtig)
• Die Funktion ist privat
• Die Funktion beendet das Programm
• Die Funktion ist statisch

Was liefert async?

• Ein Ergebnis, das du später mit await abholst (richtig)
• Sofort einen String
• Nichts
• Einen Thread

Womit baut man deklarative UIs in Android?

• Jetpack Compose (richtig)
• Swing
• JavaFX
• jQuery

Weiter im Kurs

Zurück: Fehler, Dateien und Java-Interop

Weiter: Referenz und Spickzettel

Alle Kapitel: Kotlin im Überblick