CoroutineScope — bu nima, hayot doirasi va korutinalarda ishlashi

Kotlin-da CoroutineScope nima?

CoroutineScope — bu kotlinx.coroutines kutubxonasidagi korutinalar uchun konteyner bo’lib xizmat qiladigan fundamental interfeysdir. U korutinalarning hayot chegaralarini belgilaydi: scope tugaganda, uning ichidagi barcha korutinalar avtomatik ravishda bekor qilinadi.

public interface CoroutineScope {
    public val coroutineContext: CoroutineContext
}

Interfeys faqat bitta maydonni o’z ichiga oladi — coroutineContext. U orqali scope unda ishga tushirilgan barcha korutinalar uchun dispetcher (Dispatcher), topshiriq (Job), istisnolarni boshqarish va kontekstning boshqa elementlarini ta’minlaydi.

kotlinx.coroutines kutubxonasidagi roli

Barcha korutina ishga tushirish funksiyalari — launch, async, runBlocking — CoroutineScope ga kengaytma funksiyalardir. Bu shuni anglatadiki, ularni faqat scope ob’ekti mavjud bo’lganda chaqirish mumkin. Bunday dizayn har bir korutinaning aniq belgilangan ota-onasi va hayotiy siklga ega bo’lishini kafolatlaydi.

CoroutineScope qayerda qo’llaniladi

Android-da har bir arxitektura komponenti o’z scope-iga ega: ViewModel uchun viewModelScope, Activity/Fragment uchun lifecycleScope. Server ilovalarida scope HTTP so’rovi yoki ma’lumotlar bazasi bilan bog’lanishlar hovuziga bog’lanishi mumkin.

CoroutineScope qanday ishlaydi: Job va strukturaviy raqobat

CoroutineScope ning ichki tuzilishini tushunish Job tushunchasi va strukturaviy raqobat prinsipi bilan tanishishni talab qiladi.

Job — korutina topshirig’i

Har bir korutina ishga tushirilganda Job ob’ektini qaytaradi (yoki async uchun Deferred). Job aniq hayotiy siklga ega bo’lgan topshiriqni ifodalaydi: New, Active, Completing, Completed, Cancelling, Cancelled. Job ob’ektlari daraxtsimon tuzilma hosil qiladi:

• Ota Job — korutina ishga tushirilgan scope
• Qaram Job — launch/async orqali ishga tushirilgan har bir korutina
• Ota-onani bekor qilish → barcha bolalarni bekor qilish
• Boladagi istisno → ota-onani bekor qilish (supervisorScope dan tashqari)

Strukturaviy raqobat prinsipi

Strukturaviy raqobat — Kotlin Coroutines ning asosiy arxitektura prinsipi bo’lib, korutinaning umr ko’rish muddati uning scope-ining umr ko’rish muddatiga bog’langan. Bu „fire-and-forget” modelidan farq qiladi, bu erda korutina scope tugaganidan keyin ham yashashda davom etadi. Strukturaviy raqobatning afzalliklari:

• Bashorat qilinadigan hayotiy sikl — scope tugaganda barcha korutinalar to’xtatilishi kafolatlanadi
• Avtomatik xato boshqaruvi — har qanday qaram korutinadagi istisno scope-ga tarqaladi
• Oqishlarning yo’qligi — scope tugaganidan keyin hech qanday korutina faol qolmaydi
• Aniq iyerarxiya — kod parallel operatsiyalarning mantiqiy tuzilishini aks ettiradi

CoroutineScope ning hayotiy sikli

scope.cancel() chaqirilganda, Job scope Cancelled holatiga o’tadi, bu esa barcha qaram Job-larni rekursiv ravishda bekor qiladi. Bekor qilinganidan keyin scope faqat yangi CoroutineScope nusxasini yaratish orqali qayta ishlatilishi mumkin.

CoroutineScope yaratish va sozlash

CoroutineScope fabrika funksiyasi orqali yoki sinfda interfeysni amalga oshirish orqali yaratilishi mumkin. Ikkala yondashuvni ko’rib chiqamiz.

CoroutineScope() fabrika funksiyasi

val scope = CoroutineScope(Dispatchers.Default + SupervisorJob())

scope.launch {
    println("${Thread.currentThread().name} da ishlaydi")
}

Fabrika funksiyasi CoroutineContext ni qabul qiladi va belgilangan kontekst bilan scope yaratadi. Misolda CPU intensiv topshiriqlar uchun Dispatchers.Default va qaram korutinalar orasidagi istisnolarni izolyatsiya qiluvchi SupervisorJob ishlatilgan.

Kompozitsiya orqali interfeysni amalga oshirish

class MyRepository {
    private val scope = CoroutineScope(Dispatchers.IO + Job())

    suspend fun fetchData(): Data = scope.async {
        api.getData()
    }.await()

    fun cleanup() {
        scope.cancel()
    }
}

Scope-ni sinf maydoni sifatida saqlaymiz va uni bekor qilish uchun qo’lda cleanup ni chaqiramiz. Bu boshqariladigan hayotiy siklli komponentlar — masalan, repozitoriylar yoki menejerlar uchun mos keladi.

Delegatsiya orqali amalga oshirish

Kotlin by kalit so’91 orqali CoroutineScope amalga oshirilishini delegatsiya qilishga imkon beradi:

class DataLoader : CoroutineScope by CoroutineScope(Dispatchers.IO) {
    fun load() {
        launch {
            // korutina DataLoader scope-da ishlaydi
        }
    }
}

Bunday yondashuv sinfning o’zi scope bo’lganda va korutina ishga tushirish usullarini taqdim etmoqchi bo’lganda qulay. Biroq ehtiyot bo’ling: sinf CoroutineScope ning barcha usullarini, jumladan cancel ni meros qilib oladi, bu esa inkapsulyatsiyani buzishi mumkin.

GlobalScope va moslashtirilgan CoroutineScope

GlobalScope — butun ilova uchun CoroutineScope singletonidir. Uni ishlab chiqarish kodida ishlatish rasman tavsiya etilmaydi.

GlobalScope muammolari

• Strukturaviy raqobatning yo’qligi — GlobalScope-dagi korutinalar komponentning hayotiy siklga bog’lanmagan
• Xotira oqishi — korutina Activity/Fragment yopilgandan keyin ham ishlashda davom etishi mumkin
• Qiyin sinov — GlobalScope-ni testlarda almashtirib bo’lmaydi
• Nazorat qilib bo’lmaydigan resurs iste’moli — ko’plab korutinalar kutilganidan uzoqroq ishlashi mumkin

GlobalScope qachon oqlanadi

JetBrains GlobalScope ni faqat kamdan-kam stsenariylarda ruxsat beradi: barcha Activity-lar yopilgandan keyin ham yashashi kerak bo’lgan ilova darajasidagi fon jarayonlari (masalan, ma’lumotlarni sinxronlash, analitika). Ammo bu hollarda ham CoroutineScope(SupervisorJob()) bilan o’z scope-ingizni yaratish afzalroqdir.

Tavsiya

Har doim aniq hayotiy sikl boshqaruvi bilan moslashtirilgan CoroutineScope-dan foydalaning. Android-da bu viewModelScope va lifecycleScope. Server ilovalarida har bir so’rov yoki ulanish hovuzi uchun scope yarating.

coroutineScope vs supervisorScope: farqi nimada

Ikkala funksiya ham parallel topshiriqlar uchun vaqtinchalik scope yaratadigan suspend funksiyalardir, ammo ularning istisnolar paytidagi xatti-harakati tubdan farq qiladi.

Qachon coroutineScope ni tanlash kerak

coroutineScope-dan bir nechta parallel operatsiyalar yagona atom operatsiyani tashkil qilganda foydalaning. Masalan, uchta serverdan ma’lumotlarni yuklash: agar bitta so’rov muvaffaqiyatsiz bo’lsa, qolganlari ma’nosizdir.

suspend fun loadProductPage(): ProductPage = coroutineScope {
    val product = async { api.getProduct() }
    val reviews = async { api.getReviews() }
    ProductPage(product.await(), reviews.await())
}

Agar getProduct yoki getReviews istisno tashlasa — ikkala korutina bekor qilinadi va istisno chaqiruvchi kodga tarqaladi.

Qachon supervisorScope ni tanlash kerak

supervisorScope-dan parallel operatsiyalar bir-biriga bog’liq bo’lmaganda foydalaning. Masalan, bir nechta mustaqil bo’limlarda profil ma’lumotlarini yuklash: agar tavsiyalar bo’limi muvaffaqiyatsiz bo’lsa, profil sarlavhasi va do’stlar ro’yxati ko’rsatilishi kerak.

CoroutineScope bilan ishlashda odatiy xatolar

Kotlin-da CoroutineScope dan foydalanishda dasturchilarning eng keng tarqalgan xatolarini ko’rib chiqamiz.

Xato 1: Scope-ni bekor qilishni unutish

Korutina oqishining eng keng tarqalgan stsenariysi — komponent tugaganda cancel chaqirmasdan scope yaratish. Agar scope bekor qilinmasa, korutinalar ob’ektlarga havolalarni ushlab, ishlashda davom etadi. Android-da avtomatik bekor qilinadigan viewModelScope yoki lifecycleScope-dan foydalaning.

Xato 2: Activity yoki Fragment-da GlobalScope dan foydalanish

GlobalScope Android komponentlarining hayotiy siklini e’tiborsiz qoldiradi. Activity yopilgandan keyin GlobalScope-da ishga tushirilgan korutina ishlashda davom etadi va UI-ni yangilashga harakat qiladi — bu crash-ga olib keladi. UI komponentlari uchun har doim lifecycleScope-dan foydalaning.

Xato 3: Bekor qilingan scope-ni qayta ishlatish

cancel() chaqirilgandan keyin scope-ni qayta ishlatib bo’lmaydi — undagi barcha korutinalar allaqachon tugallangan. Fabrika funksiyasi orqali yangi CoroutineScope nusxasini yarating. Job() qayta faollashtirishni qo’llab-quvvatlamaydi.

Xato 4: CoroutineScope interfeysini noto’g’ri delegatsiya qilish

by orqali delegatsiya qilishda sinf istalgan joydan chaqirilishi mumkin bo’lgan ommaviy cancel() usulini oladi, bu inkapsulyatsiyani buzadi. Scope-ni xususiy maydon sifatida saqlang, interfeysni delegatsiya qilmang.