Jak synchronizovat korutiny v Androidu?

Pro synchronizaci korutin v Androidu lze použít několik přístupů v závislosti na konkrétním úkolu:

• Join: Čekání na dokončení jiné korutiny.

  // Spouštíme první korutinu
  val job1 = CoroutineScope(Dispatchers.Default).launch {
      delay(1000)
      println("Job 1 hotovo")
  }
  
  // Spouštíme druhou korutinu
  val job2 = CoroutineScope(Dispatchers.Default).launch {
      delay(500)
      println("Job 2 hotovo")
  }
  
  // Čekáme na dokončení obou korutin
  job1.join()
  job2.join()
  
  println("Všechny úkoly hotovo")
  

• Await: Čekání na výsledek asynchronní operace reprezentované Deferred.

  // Asynchronní operace vracející výsledek
  val deferredResult = CoroutineScope(Dispatchers.Default).async {
      delay(1000)
      "Výsledek z async"
  }
  
  // Čekáme na výsledek
  val result = deferredResult.await()
  println(result)
  

• CoroutineScope.coroutineScope: Vytvoření nové oblasti viditelnosti, která skončí až po dokončení všech podřízených korutin. Užitečné pro strukturovanou konkurenci.

  suspend fun doParallelWork() {
      coroutineScope { // Vytváříme novou strukturovanou konkurenční oblast
          launch { delay(1000); println("Úkol 1 hotovo") }
          launch { delay(500); println("Úkol 2 hotovo") }
      } // Tento bod bude dosažen až po dokončení úkolu 1 a úkolu 2
      println("Všechny paralelní úkoly hotovo")
  }
  

• Semantika aktorů (Channel): Pro výměnu zpráv a synchronizaci přístupu ke změnitelným datům mezi korutinami.

  // Vytváříme kanál pro výměnu Int
  val channel = Channel<Int>()
  
  CoroutineScope(Dispatchers.Default).launch {
      // Odesíláme data do kanálu
      for (i in 1..5) {
          channel.send(i)
      }
      channel.close() // Uzavření kanálu po odeslání
  }
  
  CoroutineScope(Dispatchers.Default).launch {
      // Přijímáme data z kanálu
      for (value in channel) {
          println("Přijato $value")
      }
  }
  

• Mutex: Pro zajištění exkluzivního přístupu ke sdílenému zdroji.

  import kotlinx.coroutines.sync.Mutex
  import kotlinx.coroutines.sync.withLock
  
  val mutex = Mutex()
  var counter = 0
  
  suspend fun incrementCounter() {
      mutex.withLock { // Získání mutexu
          counter++
          // Mutex bude automaticky uvolněn při opuštění bloku
      }
  }
  

Volba metody závisí na tom, co přesně je potřeba synchronizovat: čekání na dokončení, získání výsledku, řízení paralelních úkolů, výměnu dat nebo exkluzivní přístup. coroutineScope je doporučený přístup jako výchozí pro strukturovanou konkurenci.