Android Academy · Lektion

Coroutines und Suspend-Funktionen

Schreiben Sie asynchronen Code, der wie synchroner Code lesbar ist. Verwenden Sie Suspend-Funktionen, Coroutine-Speicherbereiche und Dispatcher (IO, Main, Default).

Coroutines und Suspend-Funktionen ist eine kostenlose Android Academy-Lektion auf CoddyKit. Dies ist Lektion 3 von 6. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Android Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Android Academy-Kurs umfasst insgesamt 6 Lektionen.

Das Problem: UI-Thread blockieren

Android führt die gesamte UI-Arbeit im Hauptthread aus. Wenn Sie eine Netzwerkanfrage oder einen Datenbankzugriff im Hauptthread durchführen, friert die UI ein, bis der Vorgang abgeschlossen ist.

Wenn die UI länger als 5 Sekunden einfriert, zeigt Android einen Dialog mit dem Hinweis ANR (App Not Responding) an, und der Benutzer kann das Schließen Ihrer App erzwingen.

Was sind Coroutines?

Kotlin Coroutines ermöglichen es, asynchronen Code zu schreiben, der sequentiell aussieht — ohne Callbacks und ohne RxJava-Ketten.

Leichtgewichtig — Tausende Coroutines können gleichzeitig ausgeführt werden
Unterbrechbar — eine Coroutine kann pausieren und fortgesetzt werden, ohne einen Thread zu blockieren
Strukturiert — sie berücksichtigen einen Lebenszyklus (Scope)

suspend-Funktionen

Eine mit suspend markierte Funktion kann ihre Ausführung pausieren, ohne den Thread zu blockieren. Sie kann nur aus einer anderen suspend-Funktion oder einem Coroutine-Scope aufgerufen werden.

import kotlinx.coroutines.*

suspend fun fetchData(): String {
    delay(1000)  // simulates 1 second network call
    return "Data loaded!"
}

fun main() = runBlocking {
    println("Fetching...")
    val result = fetchData()  // suspends here, doesn't block
    println(result)           // Data loaded!
    println("Done")
}

Coroutine-Scope

Jede Coroutine läuft innerhalb eines Scopes, der ihren Lebenszyklus definiert:

viewModelScope — wird abgebrochen, wenn das ViewModel gelöscht wird
lifecycleScope — wird abgebrochen, wenn die Activity bzw. das Fragment zerstört wird
GlobalScope — läuft für immer (vermeiden Sie diesen Scope)
runBlocking — nur für Tests

launch vs. async

Zwei Möglichkeiten, eine Coroutine zu starten:

launch { } — startet die Ausführung ohne Rückgabewert
async { }.await() — gibt ein Ergebnis zurück, auf das Sie warten können

import kotlinx.coroutines.*

fun main() = runBlocking {
    // launch: no return value
    launch {
        delay(500)
        println("launch done")
    }

    // async: returns a Deferred<T>
    val deferred = async {
        delay(300)
        42
    }
    val result = deferred.await()
    println("async result: $result")
}

Dispatcher: Welcher Thread?

Dispatcher legen fest, auf welchem Thread bzw. welchen Threads die Coroutine ausgeführt wird:

Dispatchers.Main — UI-Thread (zum Aktualisieren von Ansichten)
Dispatchers.IO — für Netzwerk- und Festplattenoperationen
Dispatchers.Default — für CPU-intensive Aufgaben

Verwenden Sie withContext(Dispatchers.IO) { }, um innerhalb einer Coroutine den Dispatcher zu wechseln.

Beispiel für viewModelScope

Rufen Sie Daten in einem ViewModel ab, ohne die UI zu blockieren:

import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import kotlinx.coroutines.*

class DataViewModel : ViewModel() {

    fun loadData() {
        viewModelScope.launch {
            // Switch to IO thread for network
            val data = withContext(Dispatchers.IO) {
                // simulate network request
                delay(1000)
                "Result from server"
            }
            // Back on Main thread — safe to update UI
            _uiState.value = data
        }
    }
}

Fehlerbehandlung in Coroutines

Behandeln Sie Ausnahmen innerhalb einer Coroutine mit try/catch – genau wie in normalem Code:

viewModelScope.launch {
    try {
        val result = withContext(Dispatchers.IO) {
            api.fetchUser()  // may throw IOException
        }
        _user.value = result
    } catch (e: Exception) {
        _error.value = "Failed: ${e.message}"
    }
}

Parallele Coroutines

Führen Sie zwei Aufgaben parallel aus und warten Sie mit async/await, bis beide abgeschlossen sind:

viewModelScope.launch {
    // Both run at the same time!
    val userDeferred = async(Dispatchers.IO) { api.getUser() }
    val postsDeferred = async(Dispatchers.IO) { api.getPosts() }

    val user = userDeferred.await()
    val posts = postsDeferred.await()

    _state.value = UiState(user, posts)
}

Schnelltest

Welchen Coroutine-Dispatcher sollten Sie für Netzwerk- und Datenbankoperationen verwenden?

Zusammenfassung: Coroutines

Sie können jetzt asynchronen Code ohne Callbacks schreiben:

suspend fun — kann pausieren, ohne den Thread zu blockieren
viewModelScope.launch { } — startet eine Coroutine in einem ViewModel
withContext(Dispatchers.IO) — wechselt zu einem Hintergrund-Thread
async { }.await() — parallele Verarbeitung mit Ergebnis
try/catch funktioniert auch innerhalb von Coroutines wie gewohnt

Als Nächstes: das Repository-Muster — eine klare Trennung zwischen Datenquellen.

Häufig gestellte Fragen

Ist die Lektion „Coroutines und Suspend-Funktionen“ kostenlos?

Ja — der vollständige Text von „Coroutines und Suspend-Funktionen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Android Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Android Academy-Kurs umfasst insgesamt 6 Lektionen.

Was lerne ich in „Coroutines und Suspend-Funktionen“?

Schreiben Sie asynchronen Code, der wie synchroner Code lesbar ist. Verwenden Sie Suspend-Funktionen, Coroutine-Speicherbereiche und Dispatcher (IO, Main, Default). Du übst Android Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Android Academy zu starten?

Keine Vorkenntnisse erforderlich. Android Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 6.

Wie lange dauert die Lektion „Coroutines und Suspend-Funktionen“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Android Academy-Lektion Code schreiben und ausführen?

Ja. Jede Android Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Android Academy