suspend function: Was es ist, Syntax und Funktionsweise in Koroutinen

Was ist eine suspend function in Kotlin?

Suspend function ist eine mit dem suspend-Schlüsselwort deklarierte Funktion, die die Ausführung an einem oder mehreren Punkten anhalten kann, ohne den Thread zu blockieren. Jeder Aufruf einer Suspend-Funktion innerhalb einer anderen Suspend-Funktion ist ein potenzieller Aussetzungspunkt.

suspend fun fetchUserData(): User {
    val response = httpClient.get("/user")
    return parser.parse(response)
}

Der Kotlin-Compiler übersetzt eine solche Funktion in eine Zustandsmaschine. Jeder Aussetzungspunkt (ein Aufruf einer anderen Suspend-Funktion) wird zu einem Zustand (Label). Der aktuelle Thread wird zwischen den Zuständen freigegeben, und nach Abschluss der erwarteten Operation wird die Ausführung vom nächsten Zustand aus fortgesetzt.

Geschichte

Suspend-Funktionen erschienen in Kotlin 1.3 (2018) zusammen mit Koroutinen als experimentelles Feature und wurden in Kotlin 1.5 (2021) stabil. Davor wurde Asynchronität in Kotlin/Java durch Callbacks, RxJava und CompletableFuture erreicht. Suspend-Funktionen boten eine Alternative mit linearer Syntax und automatischer Thread-Verwaltung.

Wie Suspend-Funktionen arbeiten: Continuation und Zustandsmaschine

Das Verständnis der inneren Arbeitsweise von Suspend-Funktionen ist der Schlüssel zur korrekten Arbeit mit Koroutinen. Im Gegensatz zu regulären Funktionen wird jede Suspend-Funktion in eine Klasse mit dem Continuation-Interface kompiliert.

Continuation — der versteckte Parameter

Der Kotlin-Compiler fügt am Ende jeder Parameterliste einer Suspend-Funktion einen Parameter vom Typ Continuation hinzu. Continuation enthält:

• context — CoroutineContext (Dispatcher, Job, Kontextelemente)
• resumeWith — Methode zum Fortsetzen der Ausführung mit einem Ergebnis oder einer Ausnahme
• label — Index des aktuellen Zustands in der Zustandsmaschine

Beispiel einer Zustandsmaschine

Angenommen, wir haben eine Suspend-Funktion mit zwei Aufrufen anderer Suspend-Funktionen:

suspend fun process() {
    val a = stepOne()
    val b = stepTwo(a)
    println(b)
}

Der Compiler wandelt sie in eine Zustandsmaschine mit Labels um:

// Simplified generated code representation
fun process(cont: Continuation<Unit>): Any? {
    val cont = cont as ProcessContinuation
    when (cont.label) {
        0 -> {
            cont.label = 1
            if (stepOne(cont) == COROUTINE_SUSPENDED) return COROUTINE_SUSPENDED
        }
        1 -> {
            cont.label = 2
            val a = cont.result as TypeA
            if (stepTwo(a, cont) == COROUTINE_SUSPENDED) return COROUTINE_SUSPENDED
        }
        2 -> {
            println(cont.result)
            Unit
        }
    }
}

Wichtige Beobachtung: Wenn die Funktion COROUTINE_SUSPENDED zurückgibt, wird der aktuelle Thread freigegeben. Wenn die asynchrone Operation abgeschlossen ist, wird Continuation.resumeWith aufgerufen, und die Zustandsmaschine fährt mit dem nächsten Label fort.

Syntax von Suspend-Funktionen: Deklaration und Aufruf

Die Deklaration einer Suspend-Funktion unterscheidet sich nicht von einer regulären Funktion, außer durch das Schlüsselwort suspend vor fun. Es gibt nur eine Einschränkung: Eine Suspend-Funktion kann nur von einer Koroutine oder einer anderen Suspend-Funktion aufgerufen werden.

Basissyntax

suspend fun delayAndReturn(ms: Long): String {
    delay(ms)
    return "Done after ${ms}ms"
}

In diesem Beispiel ist delay ebenfalls eine Suspend-Funktion, die die Koroutine für die angegebene Anzahl von Millisekunden anhält, ohne den Thread zu blockieren. Nach der Verzögerung wird die Ausführung fortgesetzt.

Aufruf aus einer Koroutine

fun main() = runBlocking {
    val result = delayAndReturn(1000)
    println(result)
}

runBlocking erstellt eine Brücke zwischen der normalen Welt und Koroutinen. Innerhalb des Lambdas können beliebige Suspend-Funktionen aufgerufen werden.

Suspend-Lambdas und funktionale Typen

Kotlin unterstützt Suspend-Versionen funktionaler Typen — suspend () -> T und suspend (A) -> B. Dies ermöglicht die Übergabe asynchroner Lambdas an Funktionen höherer Ordnung:

suspend fun  withRetry(
    retries: Int = 3,
    block: suspend () -> T
): T {
    repeat(retries - 1) {
        try { return block() }
        catch (_: Exception) { delay(100) }
    }
    return block()
}

Die Funktion withRetry nimmt ein Suspend-Lambda entgegen und wiederholt dessen Ausführung bei Fehlern. Dies ist ein typisches Muster für Netzwerkanfragen mit Wiederholungsversuchen.

Wie sich Suspend-Funktionen von regulären unterscheiden

Die Unterschiede zwischen Suspend- und regulären Funktionen gehen über das bloße Hinzufügen eines Modifikators hinaus. Betrachten wir die wesentlichen Unterschiede.

Warum Suspend-Funktionen nicht von regulären aufgerufen werden können

Eine reguläre Funktion hat kein Continuation — sie hat keinen Ort, um den Zustand zu speichern, und nichts, um die Ausführung fortzusetzen. Wenn Sie eine Suspend-Funktion von einer regulären Funktion aus aufrufen müssen, verwenden Sie runBlocking (für Tests) oder CoroutineScope.launch (für die Produktion mit Lebenszyklus-Bewusstsein).

Beispiele für Suspend-Funktionen in Android

Betrachten wir drei reale Szenarien für die Verwendung von Suspend-Funktionen in Android-Apps mit Kotlin.

Beispiel 1: Room DAO mit Suspend-Abfragen

Room unterstützt Suspend-Funktionen direkt — die Abfrage wird automatisch im Hintergrundthread ausgeführt:

@Dao
interface UserDao {
    @Query("SELECT * FROM users WHERE id = :id")
    suspend fun getUser(id: Int): User?

    @Insert
    suspend fun insertUser(user: User)
}

Room verwendet intern Dispatchers.IO zur Ausführung der Abfrage, und das Ergebnis wird auf dem Dispatcher zurückgegeben, auf dem die Suspend-Funktion aufgerufen wurde.

Beispiel 2: Zusammensetzung von Suspend-Funktionen zum Bildschirmladen

class ProfileViewModel : ViewModel() {
    private val repo = ProfileRepository()

    fun loadProfile(id: String) {
        viewModelScope.launch {
            val profile = repo.getProfile(id)
            _profile.value = profile
        }
    }
}

ViewModelScope.launch erstellt eine Koroutine, in der die Suspend-Funktion getProfile aufgerufen wird. Nach Erhalt des Ergebnisses wird die UI im Hauptthread aktualisiert.

Beispiel 3: Sequenzielle asynchrone Schritte

suspend fun placeOrder(cart: Cart): OrderResult {
    val validated = validateCart(cart)
    val payment = processPayment(validated)
    val receipt = sendReceipt(payment)
    return receipt
}

Drei Suspend-Funktionen werden nacheinander ausgeführt. Bei jedem Schritt kann die Koroutine anhalten, ohne den Thread zu blockieren. Wenn ein Schritt eine Ausnahme auslöst, werden die übrigen Schritte nicht ausgeführt, was vor falschen Bestellungszuständen schützt.

Häufige Fehler bei der Arbeit mit Suspend-Funktionen

Selbst erfahrene Kotlin-Entwickler machen Fehler beim Entwurf von Suspend-Funktionen. Betrachten wir die häufigsten.

Fehler 1: Blockierende Aufrufe innerhalb von suspend

Eine Suspend-Funktion macht Code nicht automatisch asynchron. Thread.sleep(), InputStream.read() und andere blockierende Aufrufe blockieren weiterhin den Thread. Verwenden Sie withContext(Dispatchers.IO), um blockierende Operationen zu kapseln.

Fehler 2: Erstellen von Suspend-Funktionen ohne Notwendigkeit

Wenn eine Funktion keine anderen Suspend-Funktionen aufruft und keine asynchronen Operationen ausführt — ist der suspend-Modifikator überflüssig. Er fügt Overhead für die Zustandsmaschine hinzu und schränkt den Aufrufkontext ein. Machen Sie eine Funktion nur dann zu suspend, wenn sie tatsächlich anhält.

Fehler 3: Ignorieren von CancellationException

Wenn eine Koroutine abgebrochen wird, werfen Suspend-Funktionen CancellationException. Fangen Sie sie nicht gedankenlos ab — Sie berauben den aufrufenden Code der Fähigkeit, den Abbruch korrekt abzuschließen. Wenn Sie eine Abschlussoperation durchführen müssen, verwenden Sie einen finally-Block und NonCancellable.

suspend fun safeOperation() {
    try {
        doWork()
    } finally {
        withContext(NonCancellable) {
            cleanup()
        }
    }
}

Der finally-Block wird immer ausgeführt, auch bei Abbruch, und NonCancellable stellt sicher, dass die Bereinigung nicht unterbrochen wird.

Fehler 4: Aufrufen von Suspend-Funktionen aus Callbacks

Sie können eine Suspend-Funktion nicht direkt aus einem Callback aufrufen, ohne eine Koroutine zu erstellen. Verwenden Sie suspendCoroutine oder suspendCancellableCoroutine, um den Callback-Stil an Koroutinen anzupassen.