Hoe synchroniseer je coroutines in Android?

Om coroutines in Android te synchroniseren, kunnen verschillende benaderingen worden gebruikt, afhankelijk van de specifieke taak:

• Join: Wachten tot een andere coroutine is voltooid.

  // Eerste coroutine starten
  val job1 = CoroutineScope(Dispatchers.Default).launch {
      delay(1000)
      println("Job 1 voltooid")
  }
  
  // Tweede coroutine starten
  val job2 = CoroutineScope(Dispatchers.Default).launch {
      delay(500)
      println("Job 2 voltooid")
  }
  
  // Wachten tot beide coroutines klaar zijn
  job1.join()
  job2.join()
  
  println("Alle jobs voltooid")
  

• Await: Wachten op het resultaat van een asynchrone operatie weergegeven door Deferred.

  // Asynchrone operatie die een resultaat teruggeeft
  val deferredResult = CoroutineScope(Dispatchers.Default).async {
      delay(1000)
      "Resultaat van async"
  }
  
  // Resultaat afwachten
  val result = deferredResult.await()
  println(result)
  

• CoroutineScope.coroutineScope: Een nieuwe scope creëren die pas eindigt nadat alle kind-coroutines zijn voltooid. Handig voor gestructureerde gelijktijdigheid.

  suspend fun doParallelWork() {
      coroutineScope { // Nieuwe gestructureerde concurrency scope maken
          launch { delay(1000); println("Taak 1 voltooid") }
          launch { delay(500); println("Taak 2 voltooid") }
      } // Dit punt wordt alleen bereikt na het voltooien van taak 1 en taak 2
      println("Alle parallelle taken voltooid")
  }
  

• Semantiek van actoren (Channel): Voor berichtuitwisseling en synchronisatie van toegang tot wijzigbare gegevens tussen coroutines.

  // Een kanaal maken voor het uitwisselen van Int
  val channel = Channel<Int>()
  
  CoroutineScope(Dispatchers.Default).launch {
      // Gegevens naar kanaal sturen
      for (i in 1..5) {
          channel.send(i)
      }
      channel.close() // Kanaal sluiten na verzending
  }
  
  CoroutineScope(Dispatchers.Default).launch {
      // Gegevens uit kanaal ontvangen
      for (value in channel) {
          println("Ontvangen $value")
      }
  }
  

• Mutex: Om exclusieve toegang tot een gedeelde bron te garanderen.

  import kotlinx.coroutines.sync.Mutex
  import kotlinx.coroutines.sync.withLock
  
  val mutex = Mutex()
  var counter = 0
  
  suspend fun incrementCounter() {
      mutex.withLock { // Mutex verkrijgen
          counter++
          // Mutex wordt automatisch vrijgegeven bij het verlaten van het blok
      }
  }
  

De keuze van de methode hangt af van wat precies gesynchroniseerd moet worden: wachten op voltooiing, resultaat verkrijgen, beheer van parallelle taken, gegevensuitwisseling of exclusieve toegang. coroutineScope wordt standaard aanbevolen voor gestructureerde gelijktijdigheid.