Coroutine Builder: bu nima, korutin quruvchilarining turlari va ular qanday ishlaydi

Coroutine Builder nima?

Coroutine Builder — CoroutineScope va suspend-blokni qabul qiluvchi, yangi korutin yaratib ishga tushiruvchi Kotlin kengaytma funksiyasidir. Har bir quruvchi korutinning qanday bajarilishini belgilaydi: natija bilan yoki natijasiz, oqimni bloklash bilan yoki asinxron tarzda. Quruvchilar tildagi korutin modeliga kirish nuqtalaridir.

Barcha quruvchilar bola korutinlarning hayot siklini boshqaruvchi CoroutineScope orqali ishlaydi. Scope bekor qilinganda u orqali ishga tushirilgan barcha korutinlar avtomatik bekor qilinadi — bu tuzilgan konkurrentlik tamoyilidir. Bu yondashuv korutin sizib ketishining oldini oladi va bashorat qilinadigan yakunlanishni kafolatlaydi.

import kotlinx.coroutines.*

fun main() = runBlocking {
    // Quruvchilar CoroutineScope ichida ishlaydi
    val job = launch {
        delay(1000L)
        println("Dunyo!")
    }
    println("Salom,")
    job.join()
}

Korutin quruvchilarining asosiy turlari

Kotlin to'rtta o'rnatilgan korutin quruvchisini taqdim etadi: launch, async, runBlocking va produce. Ularning har biri o'z qaytariladigan turiga va qo'llanish sohasiga ega. Android mobil ishlanmasi uchun asosiylari launch va async — ular bloklamaydigan tarzda ishlaydi va arxitektura komponentlari bilan integratsiyalanadi.

Har bir quruvchi qo'shimcha parametrlarni qabul qiladi: CoroutineStart (ishga tushirish strategiyasi), CoroutineContext (dispetcher, istisnolar) va nomlangan kod bloki. Odatiy bo'lib korutin darhol ishga tushiriladi (CoroutineStart.DEFAULT).

launch: fire-and-forget ishga tushirish

launch — Android ishlanmasida eng ko'p ishlatiladigan quruvchi. Natija qaytarmaydigan korutinni ishga tushiradi va uning hayot siklini boshqarish uchun Job obyektini qaytaradi. Bu faqat yon ta'sir kerak bo'lgan operatsiyalar uchun ideal tanlovdir: ma'lumotlar bazasiga yozish, analitika yuborish, UI yangilash.

launch sintaksisi va ishlatilishi

launch quruvchisi CoroutineScope, ixtiyoriy CoroutineContext va suspend-blokni qabul qiladi. Qaytariladigan Job korutinni bekor qilish, uning tugashini kutish yoki statusni tekshirish imkonini beradi.

val scope = CoroutineScope(Dispatchers.IO + SupervisorJob())
val job: Job = scope.launch(CoroutineStart.LAZY) {
    val data = fetchFromNetwork()
    saveToDatabase(data)
}
job.start()
job.join()

CoroutineStart.LAZY parametri ishga tushirishni start() yoki join() aniq chaqirilgunga qadar kechiktiradi. Bu kechiktirilgan inisializatsiya va shartli ishga tushirish uchun foydalidir. Standart darhol ishga tushirish uchun CoroutineStart.DEFAULT ishlatiladi yoki parametr qoldiriladi.

async: natija bilan parallel hisoblashlar

async — Deferred<T> qaytaruvchi quruvchi — natijaning asinxron va'dasi. await() chaqiruvi oqimni bloklamagan holda natija olinmaguncha korutinni to'xtatib turadi. Bu Kotlin korutinlarida parallel vazifalar uchun asosiy mexanizmdir.

Ikki so'rovni parallel ishga tushirish

async bir vaqtning o'zida bir nechta mustaqil operatsiyalarni bajarish kerak bo'lganda ayniqsa samaralidir. Suspend-funksiyalarning ketma-ket chaqirilishidan farqli o'laroq, async korutinlarni parallel ishga tushiradi va umumiy bajarilish vaqtini qisqartiradi.

suspend fun fetchUserData(): UserData {
    val deferred1 = CoroutineScope(Dispatchers.IO).async { api.getProfile() }
    val deferred2 = CoroutineScope(Dispatchers.IO).async { api.getSettings() }
    val deferred3 = CoroutineScope(Dispatchers.IO).async { api.getNotifications() }
    return UserData(
        profile = deferred1.await(),
        settings = deferred2.await(),
        notifications = deferred3.await()
    )
}

Deferred Job-dan meros oladi, shuning uchun async hayot siklining barcha operatsiyalarini qo'llab-quvvatlaydi: bekor qilish, tugashini kutish, istisnolarni boshqarish. Scope bekor qilinganda Deferred bola korutinlari avtomatik bekor qilinadi.

runBlocking: blocking dunyosiga ko'prik

runBlocking — korutin tugaguncha joriy oqimni bloklaydigan yagona quruvchi. Yangi CoroutineScope yaratadi va berilgan korutinni ishga tushiradi, chaqiruvchi oqimni bloklaydi. main() kirish nuqtalarida, testlarda va blocking kod bilan integratsiyada ishlatiladi.

runBlocking qachon zarur

runBlocking uch stsenariyda asoslanadi: dasturning kirish nuqtasi (main), suspend-funksiyalarning birlik testlari va suspend ishlatib bo'lmaydigan callback-based kutubxonalar bilan integratsiya. Android ishlab chiqarish kodida asosiy oqimda runBlocking ishlatish qat'iyan tavsiya etilmaydi.

class CoroutineTest {
    @Test
    fun `test suspend function`() = runBlocking {
        val result = mySuspendFunction()
        assertEquals("expected", result)
    }
}

Testlar uchun runBlocking o'rniga kotlinx-coroutines-test bilan TestCoroutineDispatcher ishlatish tavsiya qilinadi — bu vaqtni nazorat qilishni ta'minlaydi va test muhitida blokirovkalarning oldini oladi.

Mos quruvchini qanday tanlash

Coroutine Builder tanlovi qaytariladigan natija va bajarilish stsenariysiga bog'liq. Agar operatsiya ma'lumot qaytarishni talab qilmasa — launch dan foydalaning. Agar asinxron operatsiya natijasi kerak bo'lsa — async. runBlocking ni faqat bridging uchun qo'llang, produce ni esa reaktiv oqimlar uchun Flow bilan almashtiring.

Android uchun amaliy tavsiyalar

Kotlin Coroutines ishlatadigan Android loyihalarida asosiy quruvchi juftligi launch va async dir. launch ViewModel va UseCases da korutinlarni ishga tushirish uchun, async esa tarmoq yoki ma'lumotlar bazasiga parallel so'rovlar uchun ishlatiladi. Zamonaviy kutubxonalar (Ktor, Room) allaqachon suspend-funksiyalarni qo'llab-quvvatlaydi, bu esa async ni to'g'ridan-to'g'ri ishlatishga ehtiyojni kamaytiradi.

• launch — fire-and-forget uchun (loglash, analitika, keshlashtirish)
• async — natijalarni birlashtirish bilan parallel so'rovlar uchun
• runBlocking — faqat main() va testlarda (production-da Main-threadda emas)
• produce — Flow / SharedFlow / StateFlow bilan almashtiring