Ինչպես սինխրոնիզացնել կորուտինները Android-ում?

Android-ում կորուտինների սինխրոնիզացիայի համար կարող եք օգտագործել մի քանի մոտեցումներ՝ կախված կոնկրետ առաջադրանքից.

• Join: սպասել մյուս կորուտինայի ավարտին:

  // առաջին կորուտինայի գործարկում
  val job1 = CoroutineScope(Dispatchers.Default).launch {
      delay(1000)
      println("Աշխատանքը 1 ավարտվեց")
  }
  
  // երկրորդ կորուտինայի գործարկում
  val job2 = CoroutineScope(Dispatchers.Default).launch {
      delay(500)
      println("Աշխատանքը 2 ավարտվեց")
  }
  
  // սպասել երկու կորուտինաների ավարտին
  job1.join()
  job2.join()
  
  println("Բոլոր աշխատանքները ավարտվեցին")
  

• Await: սպասել asynchronous գործողության արդյունքին, որը ներկայացված է Deferred-ով:

  // asynchronous գործողություն, որը վերադարձնում է արդյունք
  val deferredResult = CoroutineScope(Dispatchers.Default).async {
      delay(1000)
      "Async-ից արդյունք"
  }
  
  // սպասել արդյունքին
  val result = deferredResult.await()
  println(result)
  

• CoroutineScope.coroutineScope: նոր տեսադաշտ ստեղծել, որը ավարտվում է միայն բոլոր դուստր կորուտինաների ավարտից հետո:

  suspend fun doParallelWork() {
      coroutineScope { // նոր կառուցվածքային կոնկուրենցիա ստեղծում
          launch { delay(1000); println("Աշխատանք 1 ավարտվեց") }
          launch { delay(500); println("Աշխատանք 2 ավարտվեց") }
      } // այս կետը կհասցվի միայն այն ժամանակ, երբ աշխատանք 1 և 2 ավարտվեն
      println("Բոլոր հորիզոնական աշխատանքները ավարտվեցին")
  }
  

• Ակտորների սինվոլիկա (Channel): հաղորդագրությունների փոխանակման և մուտք գործելու սինխրոնիզացիայի համար՝ փոխադարձ տվյալների մուտք գործելու համար:

  // ստեղծում ենք channel՝ Int փոխանակելու համար
  val channel = Channel<Int>()
  
  CoroutineScope(Dispatchers.Default).launch {
      // ուղարկում ենք տվյալներ channel-ին
      for (i in 1..5) {
          channel.send(i)
      }
      channel.close() // փակել channel-ը ուղարկումից հետո
  }
  
  CoroutineScope(Dispatchers.Default).launch {
      // ստանում ենք տվյալներ channel-ից
      for (value in channel) {
          println("Ստացվեց $value")
      }
  }
  

• Mutex: ապահովելու էքսկլյուզիվ մուտք՝ ընդհանուր ռեսուրսին:

  import kotlinx.coroutines.sync.Mutex
  import kotlinx.coroutines.sync.withLock
  
  val mutex = Mutex()
  var counter = 0
  
  suspend fun incrementCounter() {
      mutex.withLock { // ձեռք բերում mutex
          counter++
      }
  }
  

ընտրությունը կախված է նրանից, թե ինչ է պետք սինխրոնիզացնել՝ սպասել ավարտին, արդյունք ստանալ, կառավարել համաժամանակյա առաջադրանքները, տվյալների փոխանակում կամ բացառիկ մուտք։ coroutineScope-ը որպես հիմնական մոտեցում առաջարկվում է կառուցվածքային մրցակցություն համար։