Android'de korutinleri nasıl senkronize edilir?

Android'de koroutinleri senkronize etmek için, belirli göreve bağlı olarak birkaç yaklaşım kullanılabilir:

• Join: Başka bir korutinanın tamamlanmasını beklemek.

  // İlk korutina başlatılır
  val job1 = CoroutineScope(Dispatchers.Default).launch {
      delay(1000)
      println("İş 1 tamamlandı")
  }
  
  // İkinci korutina başlatılır
  val job2 = CoroutineScope(Dispatchers.Default).launch {
      delay(500)
      println("İş 2 tamamlandı")
  }
  
  // Her iki korutina tamamlanana kadar bekle
  job1.join()
  job2.join()
  
  println("Tüm işler tamamlandı")
  

• Await: Deferred ile temsil edilen asenkron işlemin sonucunu beklemek.

  // Sonuç döndüren asenkron işlem
  val deferredResult = CoroutineScope(Dispatchers.Default).async {
      delay(1000)
      "Async'ten sonuç"
  }
  
  // Sonucu bekle
  val result = deferredResult.await()
  println(result)
  

• CoroutineScope.coroutineScope: Sadece tüm alt korutinler tamamlandıktan sonra sona erecek yeni bir alan oluşturmak. Yapılandırılmış eşzamanlılık için kullanışlı.

  suspend fun doParallelWork() {
      coroutineScope { // Yeni yapılandırılmış eşzamanlılık kapsamı oluştur
          launch { delay(1000); println("Görev 1 tamamlandı") }
          launch { delay(500); println("Görev 2 tamamlandı") }
      } // Bu nokta, görev 1 ve görev 2 tamamlandıktan sonra ulaşılır
      println("Tüm paralel görevler tamamlandı")
  }
  

• Aktörlerin semantiği (Channel): Mesaj alışverişi ve korutinler arasında değiştirilebilir verilere erişim senkronizasyonu için.

  // Int alışverişi için kanal oluştur
  val channel = Channel<Int>()
  
  CoroutineScope(Dispatchers.Default).launch {
      // Kanal aracılığıyla veri gönder
      for (i in 1..5) {
          channel.send(i)
      }
      channel.close() // Gönderim sonrası kanalı kapat
  }
  
  CoroutineScope(Dispatchers.Default).launch {
      // Kanaldan veri al
      for (value in channel) {
          println("Alındı $value")
      }
  }
  

• Mutex: Ortak kaynağa özel erişimi sağlamak için.

  import kotlinx.coroutines.sync.Mutex
  import kotlinx.coroutines.sync.withLock
  
  val mutex = Mutex()
  var counter = 0
  
  suspend fun incrementCounter() {
      mutex.withLock { // Mutex'i al
          counter++
          // Mutex, bloktan çıkarken otomatik olarak serbest bırakılır
      }
  }
  

Yöntem seçimi, tam olarak neyin senkronize edilmesi gerektiğine bağlıdır: tamamlanmayı beklemek, sonucu almak, paralel görevleri yönetmek, veri alışverişi yapmak veya özel erişim sağlamak. coroutineScope, yapılandırılmış eşzamanlılık için varsayılan olarak önerilen yaklaşımdır.