Nima uchun korutinalar bilan ishlashda sinxronizatsiya bloklari va shunga o'xshash tuzilmalarni ishlatish tavsiya etilmaydi?

Xizmatkorlik qilish uchun synchronized yoki standart kutubxonadan lock kabi bloklovchi tuzilmalarni ishlatish korutinlar bilan ishlashda resurslardan samarali foydalanmaslikka olib keladi va muammolarni yuzaga keltirishi mumkin.

Asosiy sabablari:

• Ipni bloklash: Sinxronizatsiya bloklari ipni to'xtatadi, faqat korutinlarni emas. Agar sinxronlashtirilgan blok ichida Suspending funksiyasi bajarilsa, ip bloklanadi va Suspending funksiyasi tugaguncha va blok ochilguncha davom etadi. Bu boshqa korutinlar uchun "ochlik"ni ta'minlamaydi va resurslarni noto'g'ri ishlatishga olib keladi.
• Suspending funksiyalar bilan mos kelmaslik: Korutinlarning ishlash mexanizmi (kontekst almashinuvi, davom ettirishlar) ip darajasidagi bloklarni hisobga olmaydi. Suspending funksiyasini sinxronlashtirilgan blok ichida bajarish korutinlarning bloklamasdan ishlash tabiatiga zid keladi.
• Strukturaviy raqobat prinsiplari buzilishi: Korutinlar o'zlarining bekor qilish belgilari va hierarxiyasiga ega. Ip darajasidagi bloklar bu tizimni e'tiborga olmaydi, bu esa bekor qilishlarni to'g'ri boshqarishni va hayot aylanishini murakkablashtiradi.
• Deadlock xavfi: Ip bloklari va korutinlar raqobat mexanizmlari kombinatsiyasi murakkab deadlocklarning yuzaga kelish ehtimolini oshiradi va ularni debugging qilishni qiyinlashtiradi.

Ip darajasidagi bloklar o'rniga, kotlinx.coroutines kutubxonasidan maxsus raqobat primitivalarini ishlatish tavsiya etiladi:

• Mutex: O'zaro chiqarishni ta'minlaydi. Zabitlangan mutexni olishga harakat qilayotgan korutin suspends (ipni bloklamasdan) va mutex bo'sh bo'lsa davom etadi.
• Semaphore: Resursga bir vaqtning o'zida kirish imkoniyatini cheklaydi.
• Channel: Korutinlar o'rtasida ma'lumot almashish uchun ishlatiladi.
• Atomik o'zgaruvchilar: Oddiy atomik operatsiyalar uchun.

Mutexdan foydalanish misoli:

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

val mutex = Mutex()
var counter = 0

suspend fun incrementCounter() {
    mutex.withLock {
        // Kritik bo'lim
        counter++
    }
}

fun main() = runBlocking {
    // Ko'p korutinlar yaratamiz
    repeat(1000) {
        launch {
            incrementCounter()
        }
    }
    delay(1000) // Korutinlar bajarilishini kutamiz
    println("Counter: $counter") // 1000 kutilyapti
}

mutex.withLock suspending-funksiyadir. Agar mutex band bo'lsa, withLock chaqirgan korutin to'xtatiladi va boshqa vazifalar uchun ip bo'shatiladi. Mutex mavjud bo'lsa, korutin davom etadi. Bu synchronized dan farqli o'laroq, ipni bloklamaydi.