Coroutine Builder: ano ito, mga uri ng coroutine builder at kung paano gumagana

Ano ang Coroutine Builder?

Coroutine Builder — ay isang extension function ng Kotlin na tumatanggap ng CoroutineScope at suspend-block, na lumilikha at nagpapatakbo ng bagong coroutine. Ang bawat builder ay tumutukoy kung paano isasagawa ang coroutine: mayroon o walang pagbabalik ng resulta, na may pagharang sa thread o asynchronous. Ang mga builder ay mga entry point sa modelo ng coroutine ng wika.

Lahat ng builder ay gumagana sa pamamagitan ng CoroutineScope, na namamahala sa lifecycle ng mga child coroutine. Kapag kinansela ang scope, lahat ng coroutine na pinatakbo sa pamamagitan nito ay awtomatikong kinakansela — ito ang prinsipyo ng structured concurrency. Ang pamamaraang ito ay pumipigil sa pagtagas ng coroutine at ginagarantiyahan ang predictable na pagtatapos.

import kotlinx.coroutines.*

fun main() = runBlocking {
    // Ang mga builder ay tumatakbo sa loob ng CoroutineScope
    val job = launch {
        delay(1000L)
        println("Mundo!")
    }
    println("Kumusta,")
    job.join()
}

Mga pangunahing uri ng coroutine builder

Nagbibigay ang Kotlin ng apat na built-in na coroutine builder: launch, async, runBlocking at produce. Ang bawat isa ay may sariling return type at lugar ng aplikasyon. Para sa mobile development sa Android, ang pangunahing ay launch at async — gumagana ang mga ito nang hindi humaharang at sumasama sa mga architectural component.

Ang bawat builder ay tumatanggap ng mga karagdagang parameter: CoroutineStart (estratehiya ng pagpapatakbo), CoroutineContext (dispatcher, mga exception) at pinangalanang bloke ng code. Bilang default, ang coroutine ay pinapatakbo kaagad (CoroutineStart.DEFAULT).

launch: fire-and-forget na pagpapatakbo

launch — ang pinakaginagamit na builder sa Android development. Pinapatakbo nito ang coroutine na hindi nagbabalik ng resulta at nagbabalik ng Job object para sa pamamahala ng lifecycle nito. Ito ang perpektong pagpipilian para sa mga operasyon kung saan kailangan lamang ang side effect: pag-save sa database, pagpapadala ng analytics, pag-update ng UI.

Sintaks at paggamit ng launch

Ang builder na launch ay tumatanggap ng CoroutineScope, opsyonal na CoroutineContext at suspend-block. Ang ibinabalik na Job ay nagpapahintulot na kanselahin ang coroutine, maghintay para sa pagkumpleto nito, o suriin ang status.

val scope = CoroutineScope(Dispatchers.IO + SupervisorJob())
val job: Job = scope.launch(CoroutineStart.LAZY) {
    val data = fetchFromNetwork()
    saveToDatabase(data)
}
job.start()
job.join()

Ang parameter na CoroutineStart.LAZY ay naantala ang pagpapatakbo hanggang sa explicit na pagtawag ng start() o join(). Ito ay kapaki-pakinabang para sa deferred initialization at kondisyonal na pagpapatakbo. Para sa karaniwang agarang pagpapatakbo, ginagamit ang CoroutineStart.DEFAULT o inaalis ang parameter.

async: parallel na kalkulasyon na may resulta

async — builder na nagbabalik ng Deferred<T> — isang asynchronous na pangako ng resulta. Ang pagtawag ng await() ay sumususpinde sa coroutine hanggang makuha ang resulta, nang hindi hinaharangan ang thread. Ito ang pangunahing mekanismo para sa parallel na mga gawain sa Kotlin coroutines.

Pagpapatakbo ng dalawang request nang parallel

Ang async ay lalong epektibo kapag kailangang magsagawa ng maraming independiyenteng operasyon nang sabay-sabay. Hindi tulad ng sunud-sunod na pagtawag ng suspend functions, pinapatakbo ng async ang mga coroutine nang parallel, na nagpapababa sa kabuuang oras ng pagpapatupad.

suspend fun fetchUserData(): UserData {
    val deferred1 = CoroutineScope(Dispatchers.IO).async { api.getProfile() }
    val deferred2 = CoroutineScope(Dispatchers.IO).async { api.getSettings() }
    val deferred3 = CoroutineScope(Dispatchers.IO).async { api.getNotifications() }
    return UserData(
        profile = deferred1.await(),
        settings = deferred2.await(),
        notifications = deferred3.await()
    )
}

Ang Deferred ay nagmamana mula sa Job, kaya sinusuportahan ng async ang lahat ng operasyon ng lifecycle: pagkansela, paghihintay sa pagkumpleto, paghawak ng mga exception. Kapag kinansela ang scope, ang mga child Deferred coroutine ay awtomatikong kinakansela.

runBlocking: tulay patungo sa blocking na mundo

runBlocking — ang tanging builder na humaharang sa kasalukuyang thread hanggang sa pagkumpleto ng coroutine. Lumilikha ito ng bagong CoroutineScope at pinapatakbo ang ibinigay na coroutine, na hinaharangan ang tumatawag na thread. Ginagamit sa mga entry point na main(), sa mga test, at sa integrasyon sa blocking code.

Kailan kinakailangan ang runBlocking

Ang runBlocking ay makatwiran sa tatlong sitwasyon: entry point ng application (main), unit test ng suspend functions, at integrasyon sa callback-based na mga library kung saan hindi magagamit ang suspend. Sa production code ng Android, ang paggamit ng runBlocking sa main thread ay tiyak na hindi inirerekomenda.

class CoroutineTest {
    @Test
    fun `test suspend function`() = runBlocking {
        val result = mySuspendFunction()
        assertEquals("expected", result)
    }
}

Para sa mga test, inirerekomenda ang paggamit ng kotlinx-coroutines-test na may TestCoroutineDispatcher sa halip na runBlocking — nagbibigay ito ng kontrol sa oras at iniiwasan ang mga pagharang sa kapaligiran ng pagsubok.

Paano pumili ng tamang builder

Ang pagpili ng Coroutine Builder ay nakadepende sa ibinabalik na resulta at sitwasyon ng pagpapatupad. Kung ang operasyon ay hindi nangangailangan ng pagbabalik ng data — gamitin ang launch. Kung kailangan ang resulta ng asynchronous na operasyon — async. Ilapat lamang ang runBlocking para sa bridging, at palitan ang produce ng Flow para sa reactive streams.

Mga praktikal na rekomendasyon para sa Android

Sa mga proyektong Android na gumagamit ng Kotlin Coroutines, ang pangunahing pares ng builder ay launch at async. Ang launch ay ginagamit sa ViewModel at UseCases para sa pagpapatakbo ng coroutine, at async — para sa parallel na mga request sa network o database. Ang mga modernong library (Ktor, Room) ay sumusuporta na sa suspend functions, na nagpapaliit ng pangangailangan para sa direktang paggamit ng async.

• launch — para sa fire-and-forget (pag-log, analytics, caching)
• async — para sa parallel na mga request na may pagsasama-sama ng resulta
• runBlocking — lamang sa main() at mga test (hindi sa production sa Main-thread)
• produce — palitan ng Flow / SharedFlow / StateFlow