Hogyan dolgozik a Kotlinben a több szálon?

Kotlinben a több szálú programozással kapcsolatban elsősorban kórutnákat használok. Ezek könnyebb és rugalmasabb megközelítést nyújtanak a hagyományos szálakhoz képest, minimalizálva a költségeket és egyszerűsítve a párhuzamos műveletek kezelését.

A kórutnák kezelésének kulcsfogalmai:

• Suspend-függvények: Olyan függvények, amelyek megszakíthatók és folytathatók. Ezek az aszinkron műveletek alapját képezik a kórutnákban.

  suspend fun fetchData(): String {
      delay(1000) // Példa megszakításra
      return "Adatok lekérve"
  }
  

• CoroutineScope: Meghatározza a kórutnák életciklusát és lehetővé teszi azok törlését.

  import kotlinx.coroutines.*
  
  fun main() = runBlocking { // Blokkoló végrehajtásra szolgáló CoroutineScope
      launch { // Új kórutna létrehozása ebben a Scope-ben
          // Kód a kórutnában
      }
  }
  

• Dispatcherek (Dispatchers): Meghatározzák, hogy melyik szálcsoporton fusson a kórutna.
  • Dispatchers.Default: CPU-intenzív számításokhoz.
  • Dispatchers.IO: Blokkoló I/O műveletekhez (pl. hálózat, fájlok).
  • Dispatchers.Main: UI-val való munkához (elérhető megfelelő platformokon, pl. Android).
  • Dispatchers.Unconfined: Nincs kötve konkrét szálcsoporthoz.

  import kotlinx.coroutines.*
  
  suspend fun doSomethingAsync() {
      withContext(Dispatchers.IO) { // Átkapcsolás az I/O diszpécserre
          // Blokkoló művelet végrehajtása
      }
  }
  

• Kórutnaépítők (Coroutine Builders): Funkciók a kórutnák indítására.
  • launch: Elindít egy kórutnát és Job-ot ad vissza, amit le lehet állítani.
  • async: Elindít egy kórutnát és Deferred-et ad vissza, ami lehetővé teszi az eredmény lekérését (await()).

  import kotlinx.coroutines.*
  
  suspend fun example() {
      val job = launch {
          // Párhuzamos feladat
      }
  
      val deferredResult = async {
          // Eredményt adó feladat
          "Eredmény"
      }
  
      job.cancel() // Feladat leállítása
      val result = deferredResult.await() // Eredmény lekérése
  }
  

Az erőforrásokhoz való hozzáférés szinkronizálására a kotlinx.coroutines.sync csomag eszközeit használom, például Mutex vagy Semaphore.

import kotlinx.coroutines.*
import kotlinx.coroutines.sync.*

val mutex = Mutex()
var counter = 0

suspend fun incrementCounter() {
    mutex.withLock { // Mutex zárolás a közös erőforráshoz való hozzáférés előtt
        counter++
    }
}

Bizonyos speciális esetekben, amikor közvetlenül a szálak alacsony szintű kezelésére van szükség, a java.util.concurrent csomag osztályait vagy közvetlenül a Thread és Runnable osztályokat használhatom, bár ez sokkal ritkábban fordul elő, mint a kórutnák.

A kórutnák előnyei a hagyományos szálakkal szemben:

Jellemző	Kórutnák	Hagyományos szálak
Súly	Könnyűek, sok egy szálon	Nehezek, minden szál erőforrást foglal
Átváltás	Kooperatív (suspend/resume)	Kényszerített (az OS ütemezője)
Megszakítás	Könnyű és strukturált	Bonyolult, megszakítások kezelése szükséges
Hibakeresés	Kényelmes, a verem nyomkövetése megmarad	Nehezebb lehet
Strukturáltság	Támogatja a strukturált konkurenciát	Kevésbé strukturált

A kórutnákat az hatékonyságuk, az aszinkron kód írásának egyszerűsége és az olvashatóságuk miatt preferálom, különösen összetett aszinkron műveletek sorozatánál.