Androidda korutinlarni qanday sinxronlashtirish…

Android'da koroutinlarni sinxronlashtirish uchun, aniq vazifaga qarab, bir nechta yondashuvlar mavjud:

Join: Boshqa korutinaning yakunlanishini kutish.

// Birinchi korutina ishga tushiriladi
val job1 = CoroutineScope(Dispatchers.Default).launch {
    delay(1000)
    println("Job 1 tugadi")
}

// Ikkinchi korutina ishga tushiriladi
val job2 = CoroutineScope(Dispatchers.Default).launch {
    delay(500)
    println("Job 2 tugadi")
}

// Ikkala korutinaning yakunlanishini kutamiz
job1.join()
job2.join()

println("Barcha ishlar tugadi")

Await: Deferred bilan ifodalangan asinxron operatsiyaning natijasini kutish.

// Natija qaytaradigan asinxron operatsiya
val deferredResult = CoroutineScope(Dispatchers.Default).async {
    delay(1000)
    "Async natijasi"
}

// Natijani kutamiz
val result = deferredResult.await()
println(result)

CoroutineScope.coroutineScope: Yangi doira yaratish, u faqat barcha bolalar korutinlar tugagach yakunlanadi. Strukturalangan raqobat uchun foydalidir.

suspend fun doParallelWork() {
    coroutineScope { // Yangi strukturalangan raqobat doirasini yaratamiz
        launch { delay(1000); println("Vazifa 1 tugadi") }
        launch { delay(500); println("Vazifa 2 tugadi") }
    } // Bu nuqta faqat vazifa 1 va vazifa 2 tugagach amalga oshiriladi
    println("Barcha parallel vazifalar tugadi")
}

Aktorlarning semantikas (Channel): Xabarlar almashinuvi va korutinlar o'rtasida o'zgaruvchan ma'lumotlarga kirishni sinxronlashtirish uchun.

// Int uchun kanal yaratamiz
val channel = Channel<Int>()

CoroutineScope(Dispatchers.Default).launch {
    // Kanalga ma'lumot yuboramiz
    for (i in 1..5) {
        channel.send(i)
    }
    channel.close() // Yuborishdan so'ng kanalni yopamiz
}

CoroutineScope(Dispatchers.Default).launch {
    // Kanaldan ma'lumot olamiz
    for (value in channel) {
        println("Qabul qilindi $value")
    }
}

Mutex: Umumiy resursga eksklyuziv kirishni ta'minlash uchun.

import kotlinx.coroutines.sync.Mutex
import kotlinx.coroutines.sync.withLock

val mutex = Mutex()
var counter = 0

suspend fun incrementCounter() {
    mutex.withLock { // Mutexni olamiz
        counter++
        // Mutex avtomatik ravishda blokdan chiqishda ozod qilinadi
    }
}

Yondashuv tanlovi aniq nima sinxronlashtirilishi kerakligiga bog'liq: yakunlanishni kutish, natijani olish, parallel vazifalarni boshqarish, ma'lumotlarni almashish yoki eksklyuziv kirishni ta'minlash. coroutineScope strukturalangan raqobat uchun standart tavsiya etilgan yondashuvdir.

Androidda korutinlarni qanday sinxronlashtirish mumkin?