Kooperative Abbruchbehandlung: isActive und ensureActive
Machen Sie Coroutines abbrechbar, indem Sie isActive prüfen und ensureActive aufrufen.
Kooperative Abbruchbehandlung: isActive und ensureActive ist eine kostenlose Kotlin Academy-Lektion auf CoddyKit. Dies ist Lektion 1 von 4. 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 Kotlin Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Kotlin Academy-Kurs umfasst insgesamt 4 Lektionen.
Warum kooperative Cancellation?
Kotlin-Coroutinen verwenden kooperative Cancellation: Eine abgebrochene Coroutine wird erst angehalten, wenn sie kooperiert, indem sie ihren Cancellation-Status prüft. Eine enge CPU-Schleife läuft weiter, bis sie diese Prüfung durchführt.
import kotlinx.coroutines.*
fun main() = runBlocking {
val job = launch {
var i = 0
while (true) { i++ } // never checks — never cancels!
}
delay(100)
job.cancel()
println("cancel sent but loop kept running until process ended")
}isActive prüfen
isActive ist eine Property von CoroutineScope, die nach einer angeforderten Cancellation false zurückgibt. Wenn Sie sie in einer Schleife prüfen, kooperiert die Coroutine.
import kotlinx.coroutines.*
fun main() = runBlocking {
val job = launch {
var i = 0
while (isActive) {
i++
}
println("Loop exited after $i iterations")
}
delay(10)
job.cancel()
job.join()
}ensureActive()
ensureActive() löst CancellationException aus, wenn die Coroutine abgebrochen wurde. Die Funktion ist ein direkter Ersatz für if (!isActive) throw CancellationException().
import kotlinx.coroutines.*
fun main() = runBlocking {
val job = launch {
try {
repeat(1_000_000) {
ensureActive() // throws if cancelled
// heavy computation here
}
} catch (e: CancellationException) {
println("Cancelled at iteration")
throw e
}
}
delay(5)
job.cancel()
job.join()
}yield() als kooperativer Punkt
yield() unterbricht die Coroutine kurz, sodass der Scheduler die Cancellation prüfen und andere Coroutinen ausführen kann.
import kotlinx.coroutines.*
fun main() = runBlocking {
val job = launch {
repeat(10) { i ->
yield() // cooperative cancellation point + gives up scheduler
println("Step $i")
}
}
delay(2)
job.cancel()
job.join()
println("Done")
}isActive vs. ensureActive
Verwenden Sie isActive für bedingte Logik, etwa um eine Schleife kontrolliert zu verlassen. Verwenden Sie ensureActive(), wenn die Cancellation sofort als Ausnahme weitergegeben werden soll.
import kotlinx.coroutines.*
fun main() = runBlocking {
launch {
repeat(100) { i ->
if (!isActive) {
println("Stopping at $i, cleaning up...")
return@launch
}
// work
}
}.also { delay(5); it.cancel(); it.join() }
}CancellationException ist etwas Besonderes
CancellationException wird nicht an den übergeordneten Scope weitergegeben – sie signalisiert einen regulären Abbruch. Unterdrücken Sie sie niemals, sondern werfen Sie sie erneut oder lassen Sie sie weitergegeben werden.
import kotlinx.coroutines.*
fun main() = runBlocking {
val job = launch {
try {
delay(1000)
} catch (e: CancellationException) {
println("Caught cancellation, rethrowing")
throw e // important!
}
}
delay(50)
job.cancel()
job.join()
println("Job state: ${job.isCancelled}")
}Abbruch bei CPU-intensiver Arbeit
Fügen Sie bei CPU-intensiver Arbeit an geeigneten Stellen ensureActive() oder yield() ein, damit ein rechtzeitiger Abbruch möglich ist.
import kotlinx.coroutines.*
suspend fun heavyCompute(n: Int): Long {
var result = 0L
for (i in 0..n) {
ensureActive()
result += i
}
return result
}
fun main() = runBlocking {
val job = launch(Dispatchers.Default) {
println(heavyCompute(1_000_000))
}
delay(10)
job.cancel()
job.join()
}isActive in einer benutzerdefinierten Suspend-Funktion
Sie können in jeder Suspend-Funktion über coroutineContext.isActive oder mit currentCoroutineContext().isActive auf isActive zugreifen.
import kotlinx.coroutines.*
suspend fun checkable() {
while (currentCoroutineContext().isActive) {
delay(10)
println("tick")
}
}
fun main() = runBlocking {
val job = launch { checkable() }
delay(35)
job.cancel()
job.join()
}Abbruch mit Ressourcenbereinigung
Auch bei kooperativem Abbruch können Ressourcen in finally-Blöcken bereinigt werden – die Abbruchausnahme wird durch diese Blöcke weitergegeben.
import kotlinx.coroutines.*
fun main() = runBlocking {
val job = launch {
try {
repeat(100) { i ->
ensureActive()
delay(20)
println("Working $i")
}
} finally {
println("Cleanup done")
}
}
delay(50)
job.cancel()
job.join()
}Abfragen mit isActive
Abfrageschleifen eignen sich ideal für isActive: Fragen Sie so lange ab, bis die Coroutine abgebrochen wird.
import kotlinx.coroutines.*
fun main() = runBlocking {
val job = launch {
while (isActive) {
println("Polling...")
delay(100)
}
println("Poller stopped")
}
delay(350)
job.cancel()
job.join()
}Unterschied zu Thread.interrupted()
Anders als Java-Threads verwenden Kotlin-Coroutines keine Interrupt-Flags. Der Abbruch wird durch Ausnahmen und den Zustand des Scopes modelliert, wodurch er sich kombinieren und strukturiert verwalten lässt.
import kotlinx.coroutines.*
fun main() = runBlocking {
// Kotlin way: cooperative via isActive / ensureActive
launch {
ensureActive()
println("Kotlin coroutine: cancellation is explicit and structured")
}
}Kurze Überprüfung
Welche Funktion löst sofort eine Ausnahme aus, wenn eine Coroutine abgebrochen wird?
Zusammenfassung
Kooperativer Abbruch erfordert explizite Prüfpunkte: isActive für einen bedingten Abbruch, ensureActive() zum sofortigen Auslösen einer Ausnahme und yield(), um die Ausführung zu unterbrechen und den Thread freizugeben. Unterdrücken Sie CancellationException niemals.
Häufig gestellte Fragen
Ist die Lektion „Kooperative Abbruchbehandlung: isActive und ensureActive“ kostenlos?
Ja — der vollständige Text von „Kooperative Abbruchbehandlung: isActive und ensureActive“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Kotlin Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Kotlin Academy-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „Kooperative Abbruchbehandlung: isActive und ensureActive“?
Machen Sie Coroutines abbrechbar, indem Sie isActive prüfen und ensureActive aufrufen. Du übst Kotlin 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 Kotlin Academy zu starten?
Keine Vorkenntnisse erforderlich. Kotlin 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 1 von 4.
Wie lange dauert die Lektion „Kooperative Abbruchbehandlung: isActive und ensureActive“?
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 Kotlin Academy-Lektion Code schreiben und ausführen?
Ja. Jede Kotlin 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
- Kooperative Abbruchbehandlung: isActive und ensureActive
- withTimeout und withTimeoutOrNull
- Aufräumen mit finally und NonCancellable
- Abbruchweitergabe in Coroutine-Hierarchien