Mi az a coroutine Kotlinben, és hogyan működik?

A Kotlinban a coroutine egy könnyű végrehajtási egység, amely lehetővé teszi az aszinkron, nem blokkoló kód írását olvashatóbb és szekvenciálisabb módon. Hasonló egy szállal (thread), de sokkal könnyebb, és nagy mennyiségben könnyen létrehozható.

Fő összetevők és működési elvek:

• Felfüggeszthető funkciók (Suspend Functions): A suspend kulcsszóval jelölt funkciók, amelyek képesek felfüggeszteni a végrehajtásukat anélkül, hogy blokkolnák a végrehajtó szálat. Amikor egy felfüggesztett funkció befejezi a "várakozási" műveletet (pl. hálózati kérés), folytathatja a végrehajtást ott, ahol megszakadt.
• Környezet (Coroutine context): Olyan elemek összessége, amelyek irányítják a coroutine viselkedését. Ide tartozik:
  • Job: A coroutine leírója, amely lehetővé teszi az életciklusának kezelését (megszakítás, várakozás a befejezésre).
  • CoroutineDispatcher: Meghatározza, hogy melyik szál(ak)on fog futni a coroutine. Lehetővé teszi a szálak közötti váltást.
  • CoroutineName: Opcionális név hibakereséshez.
  • CoroutineExceptionHandler: Kezeli a nem kezelt kivételeket.
• Építők (Builders): Funkciók, amelyek elindítják a coroutine végrehajtását:
  • launch: Egy új coroutine-t indít, eredményt nem ad vissza. Job-ot ad vissza.
  • async: Egy új coroutine-t indít, amely eredményt (Deferred) ad vissza. Az eredményt .await()-tel lehet lekérni.
  • runBlocking: Blokkoló építő, főként teszteléshez vagy blokkoló kóddal való integrációhoz használják.

Hogyan működik a háttérben:

A coroutine-ok nem hoznak létre külön szálakat minden feladathoz. Ehelyett, amikor egy suspend funkció felfüggesztésre kerül, a fordító kódot generál, amely menti a számítás aktuális állapotát. Amikor az eredmény elérhető, a coroutine egy a CoroutineDispatcher által kezelt szálon folytatódik. Ez úgy valósul meg, hogy a suspend funkciókat aszinkron hívásokká alakítja, folytatásokkal, lehetővé téve egy szál számára, hogy több coroutine-t futtasson, és közöttük váltson, amikor felfüggesztés történik.

Példa:

import kotlinx.coroutines.*

fun main() = runBlocking { // Blokkolja az aktuális szálat, amíg a runBlocking belsejében lévő coroutine be nem fejeződik
    println("Először")

    launch { // Új coroutine indítása háttérben
        delay(1000L) // Nem blokkoló késleltetés 1 másodpercig
        println("A késleltetés után")
    }

    println("Majd") // Ez a sor a launch coroutine befejezése előtt fog lefutni
}

A kód kimenete:

Először
Majd
A késleltetés után

Ez bemutatja a launch és delay nem blokkoló jellegét.