Kotlin Academy · Pelajaran

Propagasi Pembatalan dalam Hierarki Coroutine

Pahami cara pembatalan mengalir melalui hubungan coroutine induk-anak.

Propagasi Pembatalan dalam Hierarki Coroutine adalah pelajaran Kotlin Academy gratis di CoddyKit. Ini adalah pelajaran 4 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Kotlin Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Kotlin Academy mencakup 4 pelajaran total.

Hubungan Induk-Anak

Ketika sebuah korutin meluncurkan korutin lain dengan launch, anak tersebut bergabung dengan Job induknya. Membatalkan induk akan membatalkan semua anak.

import kotlinx.coroutines.*
fun main() = runBlocking {
    val parent = launch {
        launch { delay(1000); println("child 1") }
        launch { delay(1000); println("child 2") }
        delay(1000)
        println("parent")
    }
    delay(50)
    parent.cancel()
    parent.join()
    println("All cancelled")
}

Kegagalan Anak Membatalkan Induk

Jika seorang anak melempar pengecualian selain pembatalan, anak tersebut membatalkan induk dan semua korutin saudaranya—ini adalah perilaku bawaan Job.

import kotlinx.coroutines.*
fun main() = runBlocking {
    try {
        coroutineScope {
            launch {
                delay(50)
                throw RuntimeException("child failed")
            }
            launch {
                delay(1000)
                println("sibling — never prints")
            }
        }
    } catch (e: RuntimeException) {
        println("Caught: ${e.message}")
    }
}

Pembatalan Anak Tidak Merambat ke Atas

Pembatalan anak NOT membatalkan induk. Hanya pengecualian yang tidak tertangani yang dapat melakukannya. Induk dapat membatalkan anak kapan saja.

import kotlinx.coroutines.*
fun main() = runBlocking {
    val parent = launch {
        val child = launch {
            delay(1000)
            println("child done")
        }
        delay(50)
        child.cancel()  // cancels child
        child.join()
        println("parent still running")  // parent is fine
    }
    parent.join()
}

coroutineScope dibandingkan dengan GlobalScope

coroutineScope membuat cakupan anak: pembatalan dan kesalahan merambat. GlobalScope membuat korutin tanpa induk—hindari penggunaannya dalam produksi.

import kotlinx.coroutines.*
fun main() = runBlocking {
    try {
        coroutineScope {
            launch { delay(50); throw RuntimeException("error") }
        }
    } catch (e: Exception) {
        println("coroutineScope propagated: ${e.message}")
    }
    // GlobalScope.launch { } would NOT propagate to runBlocking
}

Membatalkan Subpohon

Setiap launch atau async mengembalikan Job. Batalkan sebuah tugas untuk membatalkan seluruh subpohonnya, termasuk semua peluncuran bersarang.

import kotlinx.coroutines.*
fun main() = runBlocking {
    val root = launch {
        launch {
            launch { delay(1000); println("deep") }
            delay(1000)
        }
    }
    delay(50)
    root.cancel()
    root.join()
    println("Whole subtree cancelled")
}

join() Setelah cancel()

Selalu panggil join() setelah cancel() untuk menunggu korutin dan anak-anaknya benar-benar berhenti sebelum melanjutkan.

import kotlinx.coroutines.*
fun main() = runBlocking {
    val job = launch {
        try { delay(1000) }
        finally { println("cleanup ran") }
    }
    delay(50)
    job.cancel()
    job.join()  // waits for finally to complete
    println("Proceeded after join")
}

cancelAndJoin()

job.cancelAndJoin() adalah kemudahan yang membatalkan lalu menggabungkan, setara dengan cancel() + join().

import kotlinx.coroutines.*
fun main() = runBlocking {
    val job = launch {
        try { delay(1000) }
        finally { println("cleanup") }
    }
    delay(50)
    job.cancelAndJoin()  // cancel + join in one call
    println("Done")
}

Perambatan melalui async

Dengan async, pengecualian disimpan dalam Deferred dan dilempar saat Anda memanggil await(). Pengecualian tersebut tetap merambat ke induk jika tidak tertangani.

import kotlinx.coroutines.*
fun main() = runBlocking {
    try {
        coroutineScope {
            val d = async { throw RuntimeException("async fail") }
            d.await()  // rethrows here
        }
    } catch (e: RuntimeException) {
        println("Caught from async: ${e.message}")
    }
}

Jaminan Konkurensi Terstruktur

Konkurensi terstruktur menjamin bahwa ketika suatu cakupan selesai, semua anaknya telah selesai. Tidak ada korutin yang bocor—semuanya selesai atau dibatalkan.

import kotlinx.coroutines.*
suspend fun doWork() = coroutineScope {
    launch { delay(100); println("work 1") }
    launch { delay(200); println("work 2") }
    // both children complete before doWork returns
}
fun main() = runBlocking {
    doWork()
    println("All work done")
}

Diagram Perambatan Pembatalan

Hierarkinya: induk dibatalkan → semua anak dibatalkan. Anak dibatalkan → hanya subpohon tersebut. Pengecualian anak → induk dibatalkan → korutin saudara dibatalkan.

import kotlinx.coroutines.*
fun main() = runBlocking {
    // Parent
    launch {
        val c1 = launch { delay(1000); println("c1") }  // child 1
        val c2 = launch { delay(1000); println("c2") }  // child 2
        delay(50)
        c1.cancel()  // only c1 cancelled
        c1.join()
        println("c2 still active: ${c2.isActive}")
        c2.cancelAndJoin()
    }.join()
}

Siklus Hidup CoroutineScope di Android

Di Android, viewModelScope dibatalkan ketika ViewModel dihapus. Semua korutin yang diluncurkan otomatis dibatalkan—tidak diperlukan pembersihan manual.

import kotlinx.coroutines.*
// Pseudocode:
// class MyViewModel : ViewModel() {
//     fun load() = viewModelScope.launch {
//         val data = repo.fetch() // cancelled if VM cleared
//         _state.value = data
//     }
// }
fun main() = runBlocking { println("viewModelScope cancels on ViewModel.onCleared()") }

Pemeriksaan Singkat

Apa yang terjadi pada korutin saudara ketika seorang anak melempar pengecualian yang tidak tertangani di bawah Job biasa?

Ringkasan

Pembatalan induk merambat ke semua anak. Kegagalan anak merambat ke induk dan korutin saudaranya (dengan Job biasa). Gunakan cancelAndJoin() untuk penghentian yang bersih. Konkurensi terstruktur memastikan tidak ada korutin yang bocor.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Propagasi Pembatalan dalam Hierarki Coroutine” gratis?

Ya — teks lengkap “Propagasi Pembatalan dalam Hierarki Coroutine” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Kotlin Academy, upgrade ke CoddyKit PRO. Kursus Kotlin Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Propagasi Pembatalan dalam Hierarki Coroutine”?

Pahami cara pembatalan mengalir melalui hubungan coroutine induk-anak. Kamu berlatih Kotlin Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Kotlin Academy?

Tidak diperlukan pengalaman sebelumnya. Kotlin Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 4 dari 4.

Berapa lama pelajaran “Propagasi Pembatalan dalam Hierarki Coroutine” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Kotlin Academy ini?

Ya. Setiap pelajaran Kotlin Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

Pembatalan Kooperatif: isActive dan ensureActive
withTimeout dan withTimeoutOrNull
Pembersihan dengan finally dan NonCancellable
Propagasi Pembatalan dalam Hierarki Coroutine

← Kembali ke Kotlin Academy