launch — esensi, memulai coroutine fire-and-forget dan cara kerjanya

Apa itu launch di Kotlin Coroutines?

launch — adalah fungsi ekstensi Kotlin, tersedia melalui import kotlinx.coroutines, yang membuat coroutine baru dalam CoroutineScope yang ditentukan. Berbeda dengan fungsi biasa, kode di dalam launch dieksekusi secara konkuren — coroutine dapat ditangguhkan (suspend) tanpa memblokir thread dan dilanjutkan nanti.

Builder launch adalah blok bangunan fundamental dari model coroutine Kotlin. Ia tidak mengembalikan nilai yang dihitung, tetapi mengembalikan objek Job yang memungkinkan kontrol eksekusi coroutine. Semua coroutine anak yang dimulai melalui launch di dalam coroutine lain terikat pada induknya.

Sintaks dan parameter launch

Builder launch didefinisikan sebagai fungsi inline dengan beberapa parameter: CoroutineScope, CoroutineContext, CoroutineStart, dan suspend-block. Parameter memiliki nilai default, membuat launch nyaman untuk skenario umum.

public fun CoroutineScope.launch(
    context: CoroutineContext = EmptyCoroutineContext,
    start: CoroutineStart = CoroutineStart.DEFAULT,
    block: suspend CoroutineScope.() -> Unit
): Job

Parameter context menerima CoroutineContext yang menggabungkan dispatcher, penangan exception, dan elemen bernama. Paling sering Dispatchers.IO, Dispatchers.Main, atau SupervisorJob untuk isolasi kesalahan dikirimkan.

Job dan manajemen siklus hidup

Job — objek yang dikembalikan yang mewakili siklus hidup coroutine. Job dapat berada dalam status: New, Active, Completing, Completed, Cancelling, Cancelled. Setiap status mencerminkan status eksekusi dan memungkinkan reaksi terhadap perubahan.

val job = CoroutineScope(Dispatchers.IO).launch {
    repeat(10) { i ->
        delay(1000L)
        println("Progres: $i")
    }
}

println("Job aktif: ${job.isActive}")
delay(2500L)
job.cancel()
println("Job dibatalkan: ${job.isCancelled}")

Job mendukung hierarki: jika coroutine induk dibatalkan, semua coroutine anak akan dibatalkan secara otomatis. SupervisorJob mengubah perilaku ini — coroutine anak tidak dibatalkan ketika salah satu dari mereka mengalami kesalahan.

Konkurensi terstruktur di launch

Konkurensi terstruktur berarti setiap coroutine dimulai dalam CoroutineScope tertentu, dan scope tidak akan selesai sampai semua coroutine anak menyelesaikan pekerjaannya. launch sepenuhnya mendukung prinsip ini — coroutine yang dimulai di dalam coroutine lain adalah anak-anaknya.

Panggilan launch bersarang

Saat launch bersarang, terbentuk pohon coroutine. Coroutine induk menunggu penyelesaian semua anak, yang menjamin urutan eksekusi yang dapat diprediksi dan menyederhanakan manajemen sumber daya.

fun main() = runBlocking {
    launch {
        launch {
            delay(1000L)
            println("Anak 1 selesai")
        }
        launch {
            delay(500L)
            println("Anak 2 selesai")
        }
        println("Semua anak selesai sebelum baris ini")
    }
}

Perilaku ini berbeda dari konkurensi berbasis thread, di mana thread anak tidak terikat pada thread induk. Di coroutine, induk tidak selesai sampai semua anak menyelesaikan pekerjaannya.

Penanganan exception di launch

Penanganan exception di launch tergantung pada tipe Job. Untuk Job biasa, exception menyebar ke coroutine induk dan membatalkannya. Untuk SupervisorJob atau SupervisorScope, exception diisolasi — kesalahan satu coroutine anak tidak mempengaruhi yang lain.

val scope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
scope.launch {
    try {
        riskyOperation()
    } catch (e: Exception) {
        println("Ditangkap: ${e.message}")
    }
}
scope.launch {
    println("Ini masih berjalan berkat SupervisorJob")
}

Untuk penanganan global exception yang tidak tertangkap, digunakan CoroutineExceptionHandler. Ia menangkap exception yang tidak ditangani di dalam coroutine dan memungkinkan pencatatan kesalahan tanpa crash aplikasi.

Contoh penggunaan launch di Android

Di Android, launch diterapkan di mana-mana: dari ViewModel hingga WorkManager. Pola utamanya adalah penggunaan lifecycleScope di Fragment dan viewModelScope di ViewModel untuk pembatalan otomatis coroutine saat siklus hidup komponen berakhir.

class ProfileViewModel : ViewModel() {
    private val repository = UserRepository()

    fun loadProfile(userId: String) {
        viewModelScope.launch(Dispatchers.IO) {
            val profile = repository.fetchProfile(userId)
            withContext(Dispatchers.Main) {
                _profileState.update { it.copy(profile = profile) }
            }
        }
    }
}

viewModelScope secara otomatis membatalkan coroutine saat ViewModel dihancurkan. Ini menghilangkan kebocoran memori dan memastikan operasi latar belakang tidak berlanjut setelah kehilangan konteks. Selain itu, withContext dapat digunakan untuk beralih antar dispatcher.