Coroutine Builder: vad är det, typer av korutinbyggare och hur de fungerar

Vad är Coroutine Builder?

Coroutine Builder — är en tilläggsfunktion i Kotlin som tar emot CoroutineScope och ett suspend-block, skapar och startar en ny korutin. Varje byggare bestämmer hur korutinen ska köras: med eller utan resultat, med blockering av tråden eller asynkront. Byggare är ingångspunkter till språkets korutinmodell.

Alla byggare arbetar genom CoroutineScope, som hanterar livscykeln för underordnade korutiner. När scopet annulleras annulleras alla korutiner som startats genom det automatiskt — detta är principen för strukturerad samtidighet. Detta tillvägagångssätt förhindrar korutinläckor och garanterar förutsägbar slutföring.

import kotlinx.coroutines.*

fun main() = runBlocking {
    // Byggare körs inom CoroutineScope
    val job = launch {
        delay(1000L)
        println("Världen!")
    }
    println("Hej,")
    job.join()
}

Huvudtyper av korutinbyggare

Kotlin tillhandahåller fyra inbyggda korutinbyggare: launch, async, runBlocking och produce. Var och en har sin egen returtyp och tillämpningsområde. För mobilutveckling på Android är de viktigaste launch och async — de fungerar icke-blockerande och integreras med arkitekturkomponenter.

Varje byggare accepterar ytterligare parametrar: CoroutineStart (startstrategi), CoroutineContext (dispatcher, undantag) och ett namngivet kodblock. Som standard startas korutinen omedelbart (CoroutineStart.DEFAULT).

launch: fire-and-forget-start

launch — den mest använda byggaren inom Android-utveckling. Den startar en korutin som inte returnerar något resultat och returnerar ett Job-objekt för att hantera dess livscykel. Detta är det ideala valet för operationer där endast en bieffekt behövs: spara i databas, skicka analysdata, uppdatera UI.

Syntax och användning av launch

Byggaren launch accepterar CoroutineScope, valfri CoroutineContext och ett suspend-block. Det returnerade Job gör det möjligt att annullera korutinen, vänta på dess slutförande eller kontrollera status.

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

Parametern CoroutineStart.LAZY fördröjer starten tills ett explicit anrop av start() eller join(). Detta är användbart för fördröjd initiering och villkorlig start. För standard omedelbar start används CoroutineStart.DEFAULT eller parametern utelämnas.

async: parallella beräkningar med resultat

async — byggare som returnerar Deferred<T> — ett asynkront löfte om resultat. Anropet await() pausar korutinen tills resultatet erhålls, utan att blockera tråden. Detta är den grundläggande mekanismen för parallella uppgifter i Kotlin-korutiner.

Starta två förfrågningar parallellt

async är särskilt effektivt när flera oberoende operationer måste utföras samtidigt. Till skillnad från sekventiell anrop av suspend-funktioner startar async korutiner parallellt, vilket förkortar den totala körtiden.

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

Deferred ärver från Job, så async stöder alla livscykeloperationer: annullering, väntan på slutförande, hantering av undantag. När scopet annulleras annulleras underordnade Deferred-korutiner automatiskt.

runBlocking: bro till blocking-världen

runBlocking — den enda byggaren som blockerar den aktuella tråden tills korutinen är slutförd. Den skapar en ny CoroutineScope och startar den angivna korutinen, vilket blockerar den anropande tråden. Används i ingångspunkter main(), i tester och vid integrering med blocking-kod.

När runBlocking är nödvändigt

runBlocking är motiverat i tre scenarier: applikationens ingångspunkt (main), enhetstester av suspend-funktioner och integrering med callback-baserade bibliotek där suspend inte kan användas. I produktionskod för Android rekommenderas användning av runBlocking på huvudtråden absolut inte.

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

För tester rekommenderas att använda kotlinx-coroutines-test med TestCoroutineDispatcher istället för runBlocking — detta ger tidskontroll och undviker blockeringar i testmiljön.

Hur man väljer rätt byggare

Valet av Coroutine Builder beror på det returnerade resultatet och körningsscenariot. Om operationen inte kräver dataåtergivning — använd launch. Om resultatet av en asynkron operation behövs — async. runBlocking tillämpas endast för bridging och produce ersätt med Flow för reaktiva strömmar.

Praktiska rekommendationer för Android

I Android-projekt som använder Kotlin Coroutines är det huvudsakliga paret av byggare launch och async. launch används i ViewModel och UseCases för att starta korutiner och async — för parallella förfrågningar till nätverk eller databas. Moderna bibliotek (Ktor, Room) stöder redan suspend-funktioner, vilket minimerar behovet av direkt användning av async.

• launch — för fire-and-forget (loggning, analys, cache)
• async — för parallella förfrågningar med sammanslagning av resultat
• runBlocking — endast i main() och tester (inte i produktion på huvudtråden)
• produce — ersätt med Flow / SharedFlow / StateFlow