launch — mohiyati, fire-and-forget koroutinlarni ishga tushirish va qanday ishlashi

Kotlin Coroutines-da launch nima?

launch — kotlinx.coroutines import orqali mavjud bo'lgan, berilgan CoroutineScope-da yangi koroutina yaratadigan Kengaytma funksiyasidir. Oddiy funksiyalardan farqli o'laroq, launch ichidagi kod konkurrent tarzda bajariladi — koroutina oqimni bloklamasdan to'xtatilishi (suspend) va keyinroq tiklanishi mumkin.

Launch builder Kotlin koroutina modelining asosiy qurilish blokidir. U hisoblangan qiymatni qaytarmaydi, lekin koroutina bajarilishini nazorat qilish imkonini beruvchi Job obyektini qaytaradi. Boshqa koroutina ichida launch orqali ishga tushirilgan barcha bola koroutinalar ota-onaga bog'lanadi.

Launch sintaksisi va parametrlari

Launch builder bir necha parametrga ega inline funksiya sifatida aniqlanadi: CoroutineScope, CoroutineContext, CoroutineStart va suspend-blok. Parametrlar standart qiymatlarga ega, bu esa launch-ni odatiy stsenariylar uchun qulay qiladi.

public fun CoroutineScope.launch(
    context: CoroutineContext = EmptyCoroutineContext,
    start: CoroutineStart = CoroutineStart.DEFAULT,
    block: suspend CoroutineScope.() -> Unit
): Job

context parametri dispetcher, istisno ishlovchisi va nomlangan elementni birlashtiruvchi CoroutineContext-ni qabul qiladi. Ko'pincha Dispatchers.IO, Dispatchers.Main yoki xatolarni izolyatsiya qilish uchun SupervisorJob uzatiladi.

Job va hayot sikli boshqaruvi

Job — koroutinaning hayot siklini ifodalovchi qaytariladigan obyekt. Job quyidagi holatlarda bo'lishi mumkin: New, Active, Completing, Completed, Cancelling, Cancelled. Har bir holat bajarilish holatini aks ettiradi va o'zgarishlarga reaksiya berishga imkon beradi.

val job = CoroutineScope(Dispatchers.IO).launch {
    repeat(10) { i ->
        delay(1000L)
        println("Taraqqiyot: $i")
    }
}

println("Job faol: ${job.isActive}")
delay(2500L)
job.cancel()
println("Job bekor qilingan: ${job.isCancelled}")

Job iyerarxiyani qo'llab-quvvatlaydi: agar ota-ona koroutina bekor qilinsa, barcha bolalar avtomatik ravishda bekor qilinadi. SupervisorJob bu xatti-harakatni o'zgartiradi — bola koroutinalar ulardan birining xatosi bilan bekor qilinmaydi.

Launch-da strukturalashtirilgan konkurrentlik

Strukturalashtirilgan konkurrentlik har bir koroutina ma'lum bir CoroutineScope-da ishga tushirilishini anglatadi va scope barcha bola koroutinalar ishini tugatmaguncha yakunlanmaydi. launch bu tamoyilni to'liq qo'llab-quvvatlaydi — boshqa koroutina ichida ishga tushirilgan koroutinalar uning bolalaridir.

Ichma-ich launch chaqiruvlari

Ichma-ich launch ishga tushirilganda koroutinalar daraxti hosil bo'ladi. Ota-ona koroutina barcha bolalarning tugashini kutadi, bu bashorat qilinadigan bajarilish tartibini kafolatlaydi va resurs boshqaruvini soddalashtiradi.

fun main() = runBlocking {
    launch {
        launch {
            delay(1000L)
            println("Bola 1 tugadi")
        }
        launch {
            delay(500L)
            println("Bola 2 tugadi")
        }
        println("Barcha bolalar bu satrdan oldin tugadi")
    }
}

Bu xatti-harakat oqimga asoslangan konkurrentlikdan farq qiladi, bunda bola oqimlar ota-onaga bog'liq emas. Koroutinalarda ota-ona tugamaydi, barcha bolalar ishini tugatmaguncha.

Launch-da istisnolarni qayta ishlash

Launch-da istisnolarni qayta ishlash Job turiga bog'liq. Oddiy Job uchun istisnolar ota-ona koroutinaga tarqaladi va uni bekor qiladi. SupervisorJob yoki SupervisorScope uchun istisnolar izolyatsiya qilinadi — bir bola koroutinaning xatosi boshqalarga ta'sir qilmaydi.

val scope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
scope.launch {
    try {
        riskyOperation()
    } catch (e: Exception) {
        println("Tutildi: ${e.message}")
    }
}
scope.launch {
    println("Bu SupervisorJob tufayli hali ham ishlaydi")
}

Tutilmagan istisnolarni global qayta ishlash uchun CoroutineExceptionHandler ishlatiladi. U koroutina ichida qayta ishlanmagan istisnolarni tutadi va dastur ishdan chiqmasdan xatoni qayd etishga imkon beradi.

Android-da launch dan foydalanish misollari

Android-da launch hamma joyda qo'llaniladi: ViewModel-dan WorkManager-gacha. Asosiy namuna — komponent hayot sikli tugaganda koroutinalarni avtomatik bekor qilish uchun Fragment-da lifecycleScope va ViewModel-da viewModelScope dan foydalanishdir.

class ProfileViewModel : ViewModel() {
    private val repository = UserRepository()

    fun loadProfile(userId: String) {
        viewModelScope.launch(Dispatchers.IO) {
            val profile = repository.fetchProfile(userId)
            withContext(Dispatchers.Main) {
                _profileState.update { it.copy(profile = profile) }
            }
        }
    }
}

viewModelScope ViewModel yo'q qilinganda koroutinalarni avtomatik bekor qiladi. Bu xotira oqishini bartaraf qiladi va fon operatsiyalari kontekst yo'qolgandan keyin davom etmasligini kafolatlaydi. Qo'shimcha ravishda dispetcherlar o'rtasida o'tish uchun withContext dan foydalanish mumkin.