Ako synchronizovať korutiny v Android?

Pre synchronizácie korutín v Android môžete použiť niekoľko prístupov v závislosti od konkrétnej úlohy:

• Join: Čakanie na dokončenie inej korutiny.

  // Spúšťame prvú korutinu
  val job1 = CoroutineScope(Dispatchers.Default).launch {
      delay(1000)
      println("Job 1 hotovo")
  }
  
  // Spúšťame druhú korutinu
  val job2 = CoroutineScope(Dispatchers.Default).launch {
      delay(500)
      println("Job 2 hotovo")
  }
  
  // Čakáme na dokončenie oboch korutín
  job1.join()
  job2.join()
  
  println("Všetky úlohy hotové")
  

• Await: Čakanie na výsledok asynchrónnej operácie reprezentovanej Deferred.

  // Asynchrónna operácia, ktorá vracia výsledok
  val deferredResult = CoroutineScope(Dispatchers.Default).async {
      delay(1000)
      "Výsledok z async"
  }
  
  // Čakáme na výsledok
  val result = deferredResult.await()
  println(result)
  

• CoroutineScope.coroutineScope: Vytvorenie novej oblasti viditeľnosti, ktorá skončí až po dokončení všetkých dcérskych korutín. Užitečné pre štruktúrovanú konkurenciu.

  suspend fun doParallelWork() {
      coroutineScope { // Vytvárame novú štruktúrovanú konkurenciu
          launch { delay(1000); println("Úloha 1 hotová") }
          launch { delay(500); println("Úloha 2 hotová") }
      } // Tento bod bude dosiahnutý až po dokončení úlohy 1 a úlohy 2
      println("Všetky paralelné úlohy hotové")
  }
  

• Semantika aktérov (Channel): Pre výmenu správ a synchronizáciu prístupu k meniteľným dátam medzi korutinami.

  // Vytvárame kanál pre výmenu Int
  val channel = Channel<Int>()
  
  CoroutineScope(Dispatchers.Default).launch {
      // Odosielame dáta do kanála
      for (i in 1..5) {
          channel.send(i)
      }
      channel.close() // Zatvárame kanál po odoslaní
  }
  
  CoroutineScope(Dispatchers.Default).launch {
      // Prijímame dáta z kanála
      for (value in channel) {
          println("Prijaté $value")
      }
  }
  

• Mutex: Pre zabezpečenie exkluzívneho prístupu ku spoločnému zdroju.

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

Voľba metódy závisí od toho, čo presne je potrebné synchronizovať: čakanie na dokončenie, získanie výsledku, riadenie paralelných úloh, výmenu dát alebo exkluzívny prístup. coroutineScope je odporúčaný prístup ako predvolený pre štruktúrovanú konkurenciu.