Kā sinhronizēt korutinas Android?

Android korutīnu sinhronizācijai var izmantot vairākus pieejas, atkarībā no konkrētā uzdevuma:

• Join: gaidīt citas korutīnas pabeigšanu:

  // Pirmās korutīnas palaišana
  val job1 = CoroutineScope(Dispatchers.Default).launch {
      delay(1000)
      println("Darbs 1 pabeigts")
  }
  
  // Otrās korutīnas palaišana
  val job2 = CoroutineScope(Dispatchers.Default).launch {
      delay(500)
      println("Darbs 2 pabeigts")
  }
  
  // Gaidīt abu korutīnu pabeigšanu
  job1.join()
  job2.join()
  
  println("Visi darbi pabeigti")
  

• Await: gaidīt asinhronas operācijas rezultātu, kas ir Deferred:

  // Asinhrona operācija, kas atgriež rezultātu
  val deferredResult = CoroutineScope(Dispatchers.Default).async {
      delay(1000)
      "Rezultāts no async"
  }
  
  // Gaidīt rezultātu
  val result = deferredResult.await()
  println(result)
  

• CoroutineScope.coroutineScope: izveidot jaunu redzamības lauku, kas beidzas tikai pēc visu bērnu korutīnu pabeigšanas. Noder strukturētai konkurencei:

  suspend fun doParallelWork() {
      coroutineScope { // izveidot jaunu strukturētu konkurences lauku
          launch { delay(1000); println("Uzdevums 1 pabeigts") }
          launch { delay(500); println("Uzdevums 2 pabeigts") }
      } // Šī vieta tiks sasniegta tikai pēc uzdevumu 1 un 2 pabeigšanas
      println("Visi paralēlie uzdevumi pabeigti")
  }
  

• Aktoru semantika (Channel): ziņojumu apmaiņai un piekļuves sinhronizācijai maināmiem datiem starp korutīnām:

  // Izveidot kanālu Int apmaiņai
  val channel = Channel<Int>()
  
  CoroutineScope(Dispatchers.Default).launch {
      // Nosūtīt datus uz kanāla
      for (i in 1..5) {
          channel.send(i)
      }
      channel.close() // aizvērt kanālu pēc sūtīšanas
  }
  
  CoroutineScope(Dispatchers.Default).launch {
      // Saņemt datus no kanāla
      for (value in channel) {
          println("Saņemts $value")
      }
  }
  

• Mutex: nodrošināt ekskluzīvu piekļuvi kopīgam resursam:

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

Izvēle ir atkarīga no tā, ko tieši nepieciešams sinhronizēt: gaidīt pabeigšanu, saņemt rezultātu, pārvaldīt paralēlas uzdevumus, apmainīties ar datiem vai nodrošināt ekskluzīvu piekļuvi. coroutineScope ir ieteicamais pieejas veids strukturētai konkurencei pēc noklusējuma.