Coroutine Builder: mi ez, a korutin builderek típusai és hogyan működnek

Mi az a Coroutine Builder?

Coroutine Builder — egy Kotlin kiterjesztési függvény, amely elfogadja a CoroutineScope-ot és egy suspend-blokkot, létrehozva és elindítva egy új korutint. Minden builder meghatározza, hogy a korutin hogyan lesz végrehajtva: eredménnyel vagy anélkül, a szál blokkolásával vagy aszinkron módon. A builderek belépési pontok a nyelv korutinmodelljébe.

Minden builder a CoroutineScope-on keresztül működik, amely kezeli a gyermek korutinok életciklusát. A scope törlésekor az összes rajta keresztül elindított korutin automatikusan törlődik — ez a strukturált konkurencia elve. Ez a megközelítés megakadályozza a korutin szivárgását és garantálja a kiszámítható befejezést.

import kotlinx.coroutines.*

fun main() = runBlocking {
    // A builderek a CoroutineScope-on belül működnek
    val job = launch {
        delay(1000L)
        println("Világ!")
    }
    println("Helló,")
    job.join()
}

A korutin builderek fő típusai

A Kotlin négy beépített korutin buildert biztosít: launch, async, runBlocking és produce. Mindegyiknek saját visszatérési típusa és alkalmazási területe van. Az Android mobilfejlesztéshez a fő builderek a launch és az async — nem blokkoló módon működnek, és integrálódnak az architektúra komponensekkel.

Minden builder további paramétereket fogad: CoroutineStart (indítási stratégia), CoroutineContext (dispatcher, kivételek) és egy elnevezett kódblokk. Alapértelmezés szerint a korutin azonnal elindul (CoroutineStart.DEFAULT).

launch: fire-and-forget indítás

launch — a leggyakrabban használt builder Android-fejlesztésben. Elindít egy korutint, amely nem ad vissza eredményt, és visszaad egy Job objektumot az életciklus kezeléséhez. Ez az ideális választás olyan műveletekhez, ahol csak mellékhatás szükséges: mentés adatbázisba, analitika küldése, UI frissítése.

A launch szintaxisa és használata

A launch builder elfogadja a CoroutineScope-ot, opcionális CoroutineContext-et és egy suspend-blokkot. A visszaadott Job lehetővé teszi a korutin törlését, befejezésére való várakozást vagy az állapot ellenőrzését.

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

A CoroutineStart.LAZY paraméter késlelteti az indítást a start() vagy join() explicit meghívásáig. Ez hasznos késleltetett inicializáláshoz és feltételes indításhoz. A szabványos azonnali indításhoz a CoroutineStart.DEFAULT használatos, vagy a paraméter elhagyható.

async: párhuzamos számítások eredménnyel

async — builder, amely Deferred<T> ad vissza — az eredmény aszinkron ígérete. Az await() hívás felfüggeszti a korutint az eredmény eléréséig, anélkül hogy blokkolná a szálat. Ez az alapvető mechanizmus a párhuzamos feladatokhoz a Kotlin korutinokban.

Két kérés párhuzamos indítása

Az async különösen hatékony, ha több független műveletet kell egyidejűleg végrehajtani. A suspend függvények szekvenciális hívásával ellentétben az async párhuzamosan indítja el a korutinokat, csökkentve a teljes végrehajtási időt.

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

A Deferred a Job-ból származik, így az async támogatja az életciklus összes műveletét: törlés, befejezésre várakozás, kivételek kezelése. A scope törlésekor a gyermek Deferred korutinok automatikusan törlődnek.

runBlocking: híd a blocking világba

runBlocking — az egyetlen builder, amely blokkolja az aktuális szálat a korutin befejezéséig. Létrehoz egy új CoroutineScope-ot, és elindítja a megadott korutint, blokkolva a hívó szálat. A main() belépési pontokban, tesztekben és blocking kóddal való integrációban használatos.

Mikor szükséges a runBlocking

A runBlocking három forgatókönyvben indokolt: az alkalmazás belépési pontja (main), a suspend függvények egységtesztjei és a callback-alapú könyvtárakkal való integráció, ahol a suspend nem használható. Android production kódban a runBlocking használata a fő szálon határozottan nem ajánlott.

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

Tesztekhez a runBlocking helyett a kotlinx-coroutines-test használata ajánlott TestCoroutineDispatcher-rel — ez időbeli ellenőrzést biztosít, és elkerüli a blokkolásokat a tesztkörnyezetben.

Hogyan válasszuk ki a megfelelő buildert

A Coroutine Builder kiválasztása a visszaadott eredménytől és a végrehajtási forgatókönyvtől függ. Ha a művelet nem igényel adatvisszaadást — használja a launch-ot. Ha az aszinkron művelet eredménye szükséges — async. A runBlocking-et csak bridginghez alkalmazza, a produce-t pedig cserélje Flow-ra a reaktív streamekhez.

Gyakorlati ajánlások Androidhoz

Az Android projektekben Kotlin Coroutines használatával a fő builder pár a launch és az async. A launch a ViewModel-ben és UseCases-ben használatos korutinok indításához, az async pedig párhuzamos hálózati vagy adatbázis-kérésekhez. A modern könyvtárak (Ktor, Room) már támogatják a suspend függvényeket, ami minimalizálja az async közvetlen használatának szükségességét.

• launch — fire-and-forgethez (naplózás, analitika, gyorsítótárazás)
• async — párhuzamos kérésekhez az eredmények egyesítésével
• runBlocking — csak main()-ben és tesztekben (nem production-ben a Main-szálon)
• produce — cserélje Flow-ra / SharedFlow-ra / StateFlow-ra