Kuidas sünkroniseerida korutinas Androidis?

Androidis korutinite sünkroneerimiseks saab kasutada mitmeid lähenemisviise, sõltuvalt konkreetsest ülesandest:

• Join: oodata teise korutina lõpetamist:

  // Esimese korutina käivitamine
  val job1 = CoroutineScope(Dispatchers.Default).launch {
      delay(1000)
      println("Töö 1 tehtud")
  }
  
  // Teise korutina käivitamine
  val job2 = CoroutineScope(Dispatchers.Default).launch {
      delay(500)
      println("Töö 2 tehtud")
  }
  
  // Oodata mõlema korutina lõpetamist
  job1.join()
  job2.join()
  
  println("Kõik tööd tehtud")
  

• Await: oodata asünkroonse operatsiooni tulemust, mis on esindatud Deferred-iga:

  // Asünkroonne operatsioon, mis tagastab tulemuse
  val deferredResult = CoroutineScope(Dispatchers.Default).async {
      delay(1000)
      "Async tulemus"
  }
  
  // Oodata tulemust
  val result = deferredResult.await()
  println(result)
  

• CoroutineScope.coroutineScope: luua uus nähtavusala, mis lõpeb alles pärast kõigi alamkorutinate lõpetamist. Kasulik struktuurse konkurentsi jaoks:

  suspend fun doParallelWork() {
      coroutineScope { // luua uus struktureeritud konkurentsiala
          launch { delay(1000); println("Ülesanne 1 tehtud") }
          launch { delay(500); println("Ülesanne 2 tehtud") }
      } // See punkt saavutatakse alles pärast ülesannete 1 ja 2 lõpetamist
      println("Kõik paralleelsed ülesanded lõpetatud")
  }
  

• Aktorite semantika (Channel): sõnumite vahetamine ja juurdepääsu sünkroneerimine muudetavate andmete vahel korutinate vahel:

  // Kanal loomine Int vahetamiseks
  val channel = Channel<Int>()
  
  CoroutineScope(Dispatchers.Default).launch {
      // andmete saatmine kanalile
      for (i in 1..5) {
          channel.send(i)
      }
      channel.close() // kanali sulgemine saatmise järel
  }
  
  CoroutineScope(Dispatchers.Default).launch {
      // andmete vastuvõtt kanalilt
      for (value in channel) {
          println("Vastuvõetud $value")
      }
  }
  

• Mutex: tagada eksklusiivne juurdepääs ühisele ressursile:

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

Valik sõltub sellest, mida täpselt vaja sünkroneerida: lõpetamise ootamine, tulemuse saamine, paralleelsete ülesannete juhtimine, andmete vahetamine või eksklusiivne juurdepääs. coroutineScope on soovitatav lähenemisviis struktuurse konkurentsi jaoks vaikimisi.