PricingLoginStart free
Kotlin Academy · Pelajaran

Pembatalan Koperatif: isActive dan ensureActive

Jadikan coroutine boleh dibatalkan dengan menyemak isActive dan memanggil ensureActive.

Pelajaran 1 daripada 413 langkah

Pembatalan Koperatif: isActive dan ensureActive ialah pelajaran Kotlin Academy percuma di CoddyKit. Ini ialah pelajaran 1 daripada 4. Sebanyak 3 pelajaran dalam laluan pembelajaran ini boleh dibaca sepenuhnya secara percuma — selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan praktikal dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Kotlin Academy, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Kotlin Academy merangkumi sejumlah 4 pelajaran.

Mengapa Pembatalan Koperatif?

Korutin Kotlin menggunakan pembatalan koperatif: korutin yang dibatalkan hanya dihentikan apabila ia bekerjasama dengan memeriksa keadaan pembatalannya. Gelung CPU yang padat tidak akan berhenti sehingga pemeriksaan itu dilakukan.

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")
}

Menyemak isActive

isActive ialah sifat pada CoroutineScope yang memulangkan false selepas pembatalan diminta. Menyemaknya dalam gelung menjadikan korutin bekerjasama.

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() menghasilkan CancellationException jika korutin dibatalkan. Ia ialah pengganti terus bagi 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() sebagai Titik Koperatif

yield() menggantung korutin buat seketika, membolehkan penjadual menyemak pembatalan dan menjalankan korutin lain.

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 berbanding ensureActive

Gunakan isActive untuk logik bersyarat (contohnya, keluar daripada gelung dengan tertib). Gunakan ensureActive() apabila anda mahu menyebarkan pembatalan sebagai pengecualian dengan serta-merta.

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 Itu Istimewa

CancellationException tidak disebarkan kepada induk — ia menandakan pembatalan biasa. Jangan sekali-kali mengabaikannya; sentiasa lemparkan semula atau biarkan ia disebarkan.

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}")
}

Kerja Berintensifkan CPU

Bagi kerja berintensifkan CPU, sisipkan ensureActive() atau yield() pada titik pemeriksaan semula jadi supaya pembatalan dapat dilakukan tepat pada masanya.

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 dalam Fungsi Penangguhan Tersuai

Anda boleh mengakses isActive dalam mana-mana fungsi penangguhan melalui coroutineContext.isActive atau dengan menggunakan currentCoroutineContext().isActive.

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()
}

Pembatalan dengan Pembersihan Sumber

Walaupun pembatalan dilakukan secara koperatif, sumber boleh dibersihkan dalam blok finally — pengecualian pembatalan masih disebarkan melaluinya.

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()
}

Pengundian dengan isActive

Gelung pengundian sangat sesuai untuk isActive: teruskan pengundian sehingga korutin dibatalkan.

import kotlinx.coroutines.*
fun main() = runBlocking {
    val job = launch {
        while (isActive) {
            println("Polling...")
            delay(100)
        }
        println("Poller stopped")
    }
    delay(350)
    job.cancel()
    job.join()
}

Perbezaan daripada Thread.interrupted()

Tidak seperti utas Java, korutin Kotlin tidak bergantung pada bendera gangguan. Pembatalan dimodelkan melalui pengecualian dan keadaan skop, menjadikannya boleh digubah dan berstruktur.

import kotlinx.coroutines.*
fun main() = runBlocking {
    // Kotlin way: cooperative via isActive / ensureActive
    launch {
        ensureActive()
        println("Kotlin coroutine: cancellation is explicit and structured")
    }
}

Semakan Pantas

Fungsi manakah yang melemparkan pengecualian serta-merta apabila korutin dibatalkan?

Jawab dalam pelajaran interaktif

Rumusan

Pembatalan koperatif memerlukan titik pemeriksaan yang jelas: isActive untuk keluar secara bersyarat, ensureActive() untuk melemparkan pengecualian serta-merta, dan yield() untuk menangguhkan pelaksanaan serta melepaskan utas. Jangan sekali-kali mengabaikan CancellationException.

Percuma untuk bermula

Pelajari Kotlin dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus
51
Pelajaran
203
Mula belajar secara percumaLihat kursus penuh

Soalan Lazim

Adakah pelajaran “Pembatalan Koperatif: isActive dan ensureActive” percuma?

Ya — sebanyak 3 pelajaran dalam laluan pembelajaran Kotlin Academy, termasuk “Pembatalan Koperatif: isActive dan ensureActive”, boleh dibaca sepenuhnya secara percuma di web ini. Selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan interaktif dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Kursus Kotlin Academy merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “Pembatalan Koperatif: isActive dan ensureActive”?

Jadikan coroutine boleh dibatalkan dengan menyemak isActive dan memanggil ensureActive. Anda berlatih Kotlin Academy menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan Kotlin Academy?

Tiada pengalaman terdahulu diperlukan. Pembelajaran Kotlin Academy di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 1 daripada 4.

Berapa lamakah pelajaran “Pembatalan Koperatif: isActive dan ensureActive” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran Kotlin Academy ini?

Ya. Setiap pelajaran Kotlin Academy menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

  1. Pembatalan Koperatif: isActive dan ensureActive
  2. withTimeout dan withTimeoutOrNull
  3. Pembersihan dengan finally dan NonCancellable
  4. Penyebaran Pembatalan dalam Hierarki Coroutine
← Kembali ke Kotlin Academy