CoroutineScope — apa itu, cakupan hidup dan kerja dalam coroutine

Apa itu CoroutineScope di Kotlin?

CoroutineScope — adalah antarmuka fundamental dari pustaka kotlinx.coroutines yang berfungsi sebagai wadah untuk coroutine. Ini menentukan batas hidup coroutine: ketika scope berakhir, semua coroutine di dalamnya secara otomatis dibatalkan.

public interface CoroutineScope {
    public val coroutineContext: CoroutineContext
}

Antarmuka hanya berisi satu bidang — coroutineContext. Melaluinya, scope menyediakan dispatcher (Dispatcher), tugas (Job), penanganan pengecualian, dan elemen konteks lainnya untuk semua coroutine yang diluncurkan di dalamnya.

Peran dalam pustaka kotlinx.coroutines

Semua fungsi peluncuran coroutine — launch, async, runBlocking — adalah fungsi ekstensi pada CoroutineScope. Ini berarti mereka hanya dapat dipanggil jika ada objek scope. Desain semacam itu menjamin bahwa setiap coroutine memiliki induk dan siklus hidup yang ditentukan dengan jelas.

Di mana CoroutineScope diterapkan

Di Android, setiap komponen arsitektur memiliki scope sendiri: viewModelScope untuk ViewModel, lifecycleScope untuk Activity/Fragment. Di aplikasi server, scope dapat dikaitkan dengan permintaan HTTP atau dengan kumpulan koneksi basis data.

Bagaimana Cara Kerja CoroutineScope: Job dan Konkurensi Struktural

Memahami struktur internal CoroutineScope memerlukan keakraban dengan konsep Job dan prinsip konkurensi struktural.

Job — Tugas Coroutine

Setiap coroutine saat diluncurkan mengembalikan objek Job (atau Deferred untuk async). Job mewakili tugas dengan siklus hidup yang ditentukan: New, Active, Completing, Completed, Cancelling, Cancelled. Objek Job membentuk struktur pohon:

• Job Induk — scope tempat coroutine diluncurkan
• Job Anak — setiap coroutine yang diluncurkan melalui launch/async
• Pembatalan induk → pembatalan semua anak
• Pengecualian pada anak → pembatalan induk (kecuali supervisorScope)

Prinsip Konkurensi Struktural

Konkurensi struktural — prinsip arsitektur utama Kotlin Coroutines, di mana masa hidup coroutine terikat pada masa hidup scope-nya. Ini kontras dengan model “fire-and-forget”, di mana coroutine terus hidup setelah scope berakhir. Keuntungan konkurensi struktural:

• Siklus hidup yang dapat diprediksi — ketika scope berakhir, semua coroutine dijamin berhenti
• Penanganan kesalahan otomatis — pengecualian pada coroutine anak mana pun menyebar ke scope
• Tidak ada kebocoran — tidak ada coroutine yang tetap aktif setelah scope berakhir
• Hierarki yang jelas — kode mencerminkan struktur logis dari operasi paralel

Siklus Hidup CoroutineScope

Ketika scope.cancel() dipanggil, Job scope masuk ke status Cancelled, yang secara rekursif membatalkan semua Job anak. Setelah pembatalan, scope hanya dapat digunakan kembali dengan membuat instance CoroutineScope baru.

Membuat dan Mengonfigurasi CoroutineScope

CoroutineScope dapat dibuat melalui fungsi pabrik atau melalui implementasi antarmuka di kelas Anda. Mari kita bahas kedua pendekatan.

Fungsi Pabrik CoroutineScope()

val scope = CoroutineScope(Dispatchers.Default + SupervisorJob())

scope.launch {
    println("Berjalan di ${Thread.currentThread().name}")
}

Fungsi pabrik menerima CoroutineContext dan membuat scope dengan konteks yang ditentukan. Dalam contoh, digunakan Dispatchers.Default untuk tugas intensif CPU dan SupervisorJob yang mengisolasi pengecualian antara coroutine anak.

Implementasi Antarmuka melalui Komposisi

class MyRepository {
    private val scope = CoroutineScope(Dispatchers.IO + Job())

    suspend fun fetchData(): Data = scope.async {
        api.getData()
    }.await()

    fun cleanup() {
        scope.cancel()
    }
}

Kami menyimpan scope sebagai bidang kelas dan secara manual memanggil cleanup untuk membatalkannya. Ini cocok untuk komponen dengan siklus hidup terkelola — misalnya, untuk repositori atau manajer.

Implementasi melalui Delegasi

Kotlin memungkinkan delegasi implementasi CoroutineScope melalui kata kunci by:

class DataLoader : CoroutineScope by CoroutineScope(Dispatchers.IO) {
    fun load() {
        launch {
            // coroutine berjalan di scope DataLoader
        }
    }
}

Pendekatan ini nyaman ketika kelas itu sendiri adalah scope dan ingin menyediakan metode peluncuran coroutine. Namun berhati-hatilah: kelas mewarisi semua metode CoroutineScope, termasuk cancel, yang dapat melanggar enkapsulasi.

GlobalScope vs CoroutineScope Kustom

GlobalScope — adalah singleton CoroutineScope untuk seluruh aplikasi. Penggunaannya dalam kode produksi secara resmi tidak direkomendasikan.

Masalah GlobalScope

• Kurangnya konkurensi struktural — coroutine di GlobalScope tidak terikat pada siklus hidup komponen
• Kebocoran memori — coroutine dapat terus berjalan setelah Activity/Fragment ditutup
• Pengujian sulit — GlobalScope tidak dapat diganti dalam pengujian
• Konsumsi sumber daya tidak terkendali — banyak coroutine dapat bekerja lebih lama dari yang diharapkan

Kapan GlobalScope Dibenarkan

JetBrains mengizinkan GlobalScope hanya dalam skenario langka: proses latar belakang tingkat aplikasi yang harus tetap hidup bahkan setelah semua Activity ditutup (misalnya, sinkronisasi data, analitik). Tetapi bahkan dalam kasus ini, lebih baik membuat scope sendiri dengan CoroutineScope(SupervisorJob()).

Rekomendasi

Selalu gunakan CoroutineScope kustom dengan manajemen siklus hidup yang eksplisit. Di Android, ini adalah viewModelScope dan lifecycleScope. Di aplikasi server, buat scope untuk setiap permintaan atau kumpulan koneksi.

coroutineScope vs supervisorScope: Apa Perbedaannya

Kedua fungsi adalah fungsi suspend yang membuat scope sementara untuk tugas paralel, tetapi perilaku mereka saat pengecualian pada dasarnya berbeda.

Kapan Memilih coroutineScope

Gunakan coroutineScope ketika beberapa operasi paralel membentuk satu operasi atom. Misalnya, memuat data dari tiga server: jika satu permintaan gagal, yang lain tidak berarti.

suspend fun loadProductPage(): ProductPage = coroutineScope {
    val product = async { api.getProduct() }
    val reviews = async { api.getReviews() }
    ProductPage(product.await(), reviews.await())
}

Jika getProduct atau getReviews melempar pengecualian — kedua coroutine dibatalkan, dan pengecualian disebarkan ke kode pemanggil.

Kapan Memilih supervisorScope

Gunakan supervisorScope ketika operasi paralel tidak bergantung satu sama lain. Misalnya, memuat data profil di beberapa bagian independen: jika bagian rekomendasi gagal, tajuk profil dan daftar teman harus ditampilkan.

Kesalahan Umum saat Bekerja dengan CoroutineScope

Mari kita bahas kesalahan paling umum pengembang saat menggunakan CoroutineScope di Kotlin.

Kesalahan 1: Lupa Membatalkan Scope

Skenario kebocoran coroutine yang paling umum — membuat scope tanpa memanggil cancel saat komponen berakhir. Jika scope tidak dibatalkan, coroutine terus berjalan, menyimpan referensi ke objek. Di Android, gunakan viewModelScope atau lifecycleScope, yang dibatalkan secara otomatis.

Kesalahan 2: Menggunakan GlobalScope di Activity atau Fragment

GlobalScope mengabaikan siklus hidup komponen Android. Coroutine yang diluncurkan di GlobalScope setelah Activity ditutup akan terus berjalan dan mencoba memperbarui UI — yang menyebabkan crash. Selalu gunakan lifecycleScope untuk komponen UI.

Kesalahan 3: Menggunakan Kembali Scope yang Sudah Dibatalkan

Setelah memanggil cancel(), scope tidak dapat digunakan kembali — semua coroutine di dalamnya sudah selesai. Buat instance CoroutineScope baru melalui fungsi pabrik. Job() tidak mendukung aktivasi ulang.

Kesalahan 4: Delegasi Antarmuka CoroutineScope yang Salah

Saat delegasi melalui by, kelas mendapatkan metode publik cancel() yang dapat dipanggil dari mana saja, melanggar enkapsulasi. Simpan scope sebagai bidang privat, jangan delegasikan antarmuka.