Jak pracujete s vícenásobností v Kotlinu?

V Kotlinu, při práci s vícenásobným vláknem používám především korytiny. Tyto poskytují lehčí a flexibilnější přístup ve srovnání s tradičními vlákny, minimalizují režii a zjednodušují správu paralelních operací.

Klíčové koncepty při práci s korytinami:

• Suspend funkce: Funkce, které mohou být pozastaveny a znovu spuštěny. Jsou základem pro asynchronní operace v korytinách.

  suspend fun fetchData(): String {
      delay(1000) // Příklad pozastavení
      return "Data získána"
  }
  

• CoroutineScope: Určuje životní cyklus korytin a umožňuje jejich zrušení.

  import kotlinx.coroutines.*
  
  fun main() = runBlocking { // CoroutineScope pro blokující provádění
      launch { // Vytvoření nové korytiny v tomto Scope
          // Kód korytiny
      }
  }
  

• Dispečeři (Dispatchers): Určují skupinu vláken, na kterých bude korytina spuštěna.
  • Dispatchers.Default: Pro intenzivní výpočty CPU.
  • Dispatchers.IO: Pro blokující I/O operace (například práce se sítí, soubory).
  • Dispatchers.Main: Pro práci s UI (dostupné na příslušných platformách, například Android).
  • Dispatchers.Unconfined: Není vázáno na konkrétní skupinu vláken.

  import kotlinx.coroutines.*
  
  suspend fun doSomethingAsync() {
      withContext(Dispatchers.IO) { // Přepnutí na I/O dispečer
          // Provádění blokující operace
      }
  }
  

• Stavitelé korytin (Coroutine Builders): Funkce pro spuštění korytin.
  • launch: Spustí korytinu a vrátí Job, který lze použít k jejímu zrušení.
  • async: Spustí korytinu a vrátí Deferred, který umožňuje získat výsledek (await()).

  import kotlinx.coroutines.*
  
  suspend fun example() {
      val job = launch {
          // Paralelní úkol
      }
  
      val deferredResult = async {
          // Úkol, který vrací výsledek
          "Výsledek"
      }
  
      job.cancel() // Zrušení úkolu
      val result = deferredResult.await() // Získání výsledku
  }
  

Pro synchronizaci přístupu ke sdíleným zdrojům používám nástroje z balíčku kotlinx.coroutines.sync, například Mutex nebo Semaphore.

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

val mutex = Mutex()
var counter = 0

suspend fun incrementCounter() {
    mutex.withLock { // Zamčení Mutex před přístupem ke sdílenému zdroji
        counter++
    }
}

V některých specifických případech, kdy je potřeba přímá správa vláken na nižší úrovni, mohu použít třídy z balíčku java.util.concurrent nebo přímo třídy Thread a Runnable, i když to je mnohem vzácnější než korytiny.

Výhody korytin ve srovnání s tradičními vlákny:

Vlastnost	Korytiny	Tradiční vlákna
Hmotnost	Lehká, mnoho na jednom vlákně	Těžká, každé vlákno zabírá zdroje
Přepínání	Kooperativní (suspend/resume)	Nucené (plánovač OS)
Zrušení	Snadné a strukturované	Složitější, vyžaduje správu přerušení
Ladění	Pohodlné, zachovává se zásobník volání	Může být složité
Strukturovanost	Podporují strukturovanou konkurenci	Méně strukturované

Upřednostňuji korytiny pro jejich efektivitu, jednoduchost psaní asynchronního kódu a lepší čitelnost, zejména při práci s složitými sekvencemi asynchronních operací.