launch — esensya, fire-and-forget na pagsisimula ng mga coroutine at kung paano ito gumagana

Ano ang launch sa Kotlin Coroutines?

launch — ay isang extension function ng Kotlin, na available sa pamamagitan ng import kotlinx.coroutines, na gumagawa ng bagong coroutine sa isang tinukoy na CoroutineScope. Hindi tulad ng mga ordinaryong function, ang code sa loob ng launch ay isinasagawa nang sabay-sabay — ang coroutine ay maaaring mag-suspend (suspend) nang hindi hinaharangan ang thread at magpatuloy mamaya.

Ang launch builder ay isang pangunahing bloke ng gusali ng modelo ng coroutine ng Kotlin. Hindi ito nagbabalik ng kinakalkulang halaga, ngunit nagbabalik ng Job object na nagpapahintulot sa pagkontrol ng execution ng coroutine. Lahat ng coroutine na anak na sinimulan sa pamamagitan ng launch sa loob ng isa pang coroutine ay nakatali sa magulang.

Sintaks at parameter ng launch

Ang launch builder ay tinukoy bilang isang inline function na may ilang parameter: CoroutineScope, CoroutineContext, CoroutineStart at suspend-block. Ang mga parameter ay may default na halaga, na ginagawang maginhawa ang launch para sa karaniwang mga sitwasyon.

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

Ang parameter na context ay tumatanggap ng CoroutineContext na pinagsasama ang dispatcher, exception handler, at pinangalanang elemento. Kadalasang ipinapadala ang Dispatchers.IO, Dispatchers.Main, o SupervisorJob para sa paghihiwalay ng error.

Job at pamamahala ng lifecycle

Job — ang ibinalik na object na kumakatawan sa lifecycle ng coroutine. Ang Job ay maaaring nasa mga estado: New, Active, Completing, Completed, Cancelling, Cancelled. Ang bawat estado ay sumasalamin sa status ng execution at nagpapahintulot ng reaksyon sa mga pagbabago.

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

println("Ang Job ay aktibo: ${job.isActive}")
delay(2500L)
job.cancel()
println("Ang Job ay nakansela: ${job.isCancelled}")

Sinusuportahan ng Job ang hierarchy: kung ang magulang na coroutine ay nakansela, lahat ng coroutine na anak ay awtomatikong makakansela. Binabago ng SupervisorJob ang pag-uugaling ito — ang mga coroutine na anak ay hindi makakansela sa error ng isa sa kanila.

Naka-estrukturang concurrency sa launch

Ang naka-estrukturang concurrency ay nangangahulugan na ang bawat coroutine ay sinisimulan sa isang tiyak na CoroutineScope, at ang scope ay hindi magtatapos hanggang ang lahat ng coroutine na anak ay matapos ang kanilang gawain. Ganap na sinusuportahan ng launch ang prinsipyong ito — ang mga coroutine na sinimulan sa loob ng isa pang coroutine ay mga anak nito.

Mga nested na tawag sa launch

Sa nested na pagsisimula ng launch, nabubuo ang isang puno ng mga coroutine. Ang magulang na coroutine ay naghihintay ng pagkumpleto ng lahat ng anak, na nag-gagarantiya ng predictable na pagkakasunod-sunod ng execution at nagpapasimple sa pamamahala ng resources.

fun main() = runBlocking {
    launch {
        launch {
            delay(1000L)
            println("Anak 1 natapos")
        }
        launch {
            delay(500L)
            println("Anak 2 natapos")
        }
        println("Lahat ng anak natapos bago ang linyang ito")
    }
}

Ang pag-uugaling ito ay naiiba sa concurrency na batay sa thread, kung saan ang mga thread na anak ay hindi nakatali sa magulang. Sa mga coroutine, ang magulang ay hindi nagtatapos hanggang ang lahat ng anak ay matapos ang kanilang gawain.

Pamamahala ng exception sa launch

Ang pamamahala ng exception sa launch ay nakadepende sa uri ng Job. Para sa ordinaryong Job, ang exception ay kumakalat sa magulang na coroutine at kinakansela ito. Para sa SupervisorJob o SupervisorScope, ang exception ay isolated — ang error ng isang coroutine na anak ay hindi nakakaapekto sa iba.

val scope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
scope.launch {
    try {
        riskyOperation()
    } catch (e: Exception) {
        println("Nahuli: ${e.message}")
    }
}
scope.launch {
    println("Ito ay tumatakbo pa rin salamat sa SupervisorJob")
}

Para sa global na pamamahala ng hindi nahuhuling exception, ginagamit ang CoroutineExceptionHandler. Hinuhuli nito ang mga exception na hindi napamahalaan sa loob ng coroutine at nagpapahintulot sa pag-log ng error nang walang crash ng application.

Mga halimbawa ng paggamit ng launch sa Android

Sa Android, ang launch ay ginagamit kahit saan: mula ViewModel hanggang WorkManager. Ang pangunahing pattern ay ang paggamit ng lifecycleScope sa Fragment at viewModelScope sa ViewModel para sa awtomatikong pagkansela ng mga coroutine sa pagtatapos ng lifecycle ng component.

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

Ang viewModelScope ay awtomatikong kinakansela ang mga coroutine kapag ang ViewModel ay nawasak. Tinatanggal nito ang mga leak ng memorya at ginagarantiya na ang mga background operation ay hindi magpapatuloy pagkatapos mawala ang konteksto. Dagdag pa, maaaring gamitin ang withContext para sa paglipat sa pagitan ng mga dispatcher.