Milyen több szálú elemeket kínál a Kotlin?

A Kotlin a következő több szálú elemeket kínálja:

• Korutinok: Könnyű súlyú szálak, amelyek szüneteltethető funkciókon alapulnak. Aszinkron és nem blokkoló végrehajtást biztosítanak.
• Korutin építők: Funkciók, amelyek korutinokat indítanak. Főbbek: launch (indít egy korutint érték visszaadása nélkül), async (indít egy korutint és Deferred-et ad vissza, amit várni lehet az eredményért).

  // Launch használati példa
  GlobalScope.launch {
      println("Üdv a korutinból ${Thread.currentThread().name}")
  }
  
  // Async használati példa
  val deferred = GlobalScope.async {
      delay(1000) // Hosszú művelet szimulálása
      "Eredmény"
  }
  val result = runBlocking { deferred.await() } // Várakozás az eredményre
  

• Dispatchers: Meghatározzák, hogy melyik szálmedencében fusson a korutin. Főbbek:
  • Dispatchers.Default: Általános szálmedence CPU-intenzív feladatokra.
  • Dispatchers.IO: Szálmedence blokkoló bemenet/kimenet műveletekhez.
  • Dispatchers.Main: A felhasználói felület szálának kezelője a megfelelő platformokon (Android, Swing).
  • Dispatchers.Unconfined: A korutin a jelenlegi szálon indul, de bármelyik szálon folytathatja.

  GlobalScope.launch(Dispatchers.IO) {
      // Bemenet/kimenet végrehajtása
  }
  

• runBlocking: Egy korutin építő függvény, amely blokkolja a jelenlegi szálat a korutin befejezéséig. Használják blokkoló és nem blokkoló kód összekapcsolására, gyakran tesztekben vagy fő függvényekben.

  runBlocking {
      launch {
          delay(500)
          println("Befejeződött ${Thread.currentThread().name}"-en)
      }
      println("Indítva ${Thread.currentThread().name}-en")
  }
  

• suspend függvények: Olyan függvények, amelyek végrehajtása szüneteltethető és folytatható. Csak más suspend függvényekből vagy korutin építőkből hívhatók.

  suspend fun doSomething() {
      delay(100) // Szüneteltetés példája
  }
  

• Job: Egy futó korutin kezelője. Metódusokat kínál a korutin életciklusának kezelésére (megszakítás, befejezés várása).

  val job = GlobalScope.launch {
     // Hosszú művelet
  }
  job.cancel() // Korutin megszakítása
  runBlocking { job.join() } // Befejezés várása
  

• CoroutineScope: Meghatározza a korutinok láthatósági területét. A benne indított korutinok automatikusan megszakadnak a terület megszakításakor. Segít a korutinok életciklusának kezelésében.

  val scope = CoroutineScope(Dispatchers.Default)
  scope.launch {
      // Korutin ebben a területen
  }
  scope.cancel() // Minden korutin megszakítása ebben a területen
  

• Csatornák (Channel): Adatátviteli primitívek a korutinok között. Lehetnek egységes irányúak (csak küldés vagy fogadás) vagy kétirányúak.

  import kotlinx.coroutines.channels.Channel
  
  val channel = Channel<Int>()
  
  runBlocking {
      launch {
          for (x in 1..5) channel.send(x * x)
          channel.close() // Fontos a csatorna lezárása
      }
      launch {
          for (y in channel) println(y)
      }
  }
  

• Mutexek (Mutex): Szinkronizációs primitívek a közös erőforrás exkluzív hozzáférésének biztosítására. Szálbiztosságot nyújtanak, lehetővé téve, hogy csak egy korutin birtokolja a mutexet egy adott időben.

  import kotlinx.coroutines.sync.Mutex
  import kotlinx.coroutines.sync.withLock
  
  val mutex = Mutex()
  var counter = 0
  
  suspend fun incrementCounter() {
      mutex.withLock {
          counter++
      }
  }
  

• Állapotok (StateFlow, SharedFlow): Adatfolyamokkal való munkára szolgáló primitívek a reaktív programozás és több szálú környezetben. A StateFlow egy "hideg" folyamat a jelenlegi állapottal, míg a SharedFlow egy "forró" folyamat az adatközvetítéshez.