Async/Await: mohiyati, async funksiyalari va await bilan ishlash

Async/Await va asinxron dasturlash nima

Async/Await — bu sinxron kod kabi chiziqli asinxron kod yozish imkonini beruvchi til konstruksiyasi. Swift-da u iOS 13 / macOS 10.15 dan Swift Concurrency framework bilan birga mavjud. Kotlin-da async/await kotlinx.coroutines kutubxonasi orqali 1.3 versiyasidan boshlab mavjud.

Async/await dan oldin asinxron kod callback, GCD yoki RxSwift yordamida qurilgan. Uyalangan callback zanjirlari callback hell — o'qish va tuzatishni qiyinlashtiradigan chuqur uyalanishga olib kelgan. Async/Await bu muammoni asinxron funksiyalarni await nuqtalarida "to'xtatish" va natija olingandan keyin qayta boshlash orqali hal qiladi.

Google ma'lumotlariga ko'ra (2025), Kotlin-da async/await dan foydalanish callback yondashuviga nisbatan asinxron kod satrlari sonini 40–60% ga kamaytiradi. Swift-da Swift Concurrency qabul qilinishi 2025 yilda nashr qilingan ilovalar orasida 68% ga yetdi. iOS 16 UIKit, SwiftUI va Foundation-da Swift Concurrency qo'llab-quvvatlashni qo'shdi va async/await ni barcha yangi Apple loyihalari uchun standart vositaga aylantirdi.

Ishlash prinsipi: to'xtatiladigan funksiyalar

Async/await ning thread-lardan asosiy farqi — blokirovkasiz to'xtatish. Funksiya await ga duch kelganda, u to'xtatiladi va joriy thread boshqa vazifalar uchun bo'shatiladi. Asinxron operatsiya tugagandan so'ng, funksiya xuddi shu yoki boshqa thread-da qayta boshlanadi. Bu cooperative multitasking deb ataladi.

Async/Await qanday ishlaydi: to'xtatish va qayta boshlash

Async funksiyasi state machine — bajarilish holatini boshqaradigan chekli holat mashinasiga kompilyatsiya qilinadi. await nuqtasida kompilyator kontekstni (lokal o'zgaruvchilar, qaytish manzili) saqlaydi va boshqaruvni runtime ga beradi. Natija tayyor bo'lganda, runtime kontekstni tiklaydi va bajarilishni davom ettiradi.

Swift da bu state machine SIL (Swift Intermediate Language) kompilyator darajasida amalga oshirilgan. Kotlin da — Continuation Passing Style (CPS) mexanizmi orqali: har bir suspend funksiyasi natijani qaytaradigan yashirin Continuation parametrini qabul qiladi. Ikkala yondashuv xotira oqishisiz xavfsiz qayta boshlashni kafolatlaydi.

• Swift — kompilyator async funksiyasini runAsync coroutine frame bilan SIL ga o'tkazadi
• Kotlin — har bir suspend funksiyasi Continuation oladi va bajarilishni dispatcher-ga topshiradi
• Ikkala til — await da thread-ni bo'shatadi, kutish vaqtida uni blokirovka qilmaydi
• Istisnolar — standart mexanizmlar orqali uzatiladi (throws / try-catch)

Async/Await vs Callbacks va GCD: yondashuvlarni taqqoslash

Callback yondashuvi operatsiya tugagandan so'ng chaqiriladigan closure ni uzatishni talab qiladi. Uchta ketma-ket so'rovda har birida xatolarni qayta ishlash bilan uch darajali uyalanish hosil bo'ladi. Async/Await xuddi shu uchta so'rovni bitta catch bloki bilan uchta ketma-ket satrga aylantiradi.

GCD (DispatchQueue) callback hell muammosini serial navbatlar va DispatchGroup orqali hal qiladi, ammo so'zli bo'lib qoladi. Oddiy vazifa — user, keyin friends, keyin UI yuklash — navbatlar, guruhlar va notify bloklarini yaratishni talab qiladi. Async/Await xuddi shu vazifani bitta funksiyada uchta satr bilan bajaradi.

Apple WWDC 2024 ma'lumotlariga ko'ra, Swift Concurrency async/await yangi kod uchun tavsiya etilgan yondashuvdir. GCD C kutubxonalari bilan integratsiya va thread-larni qayta ishlashning maxsus past darajali stsenariylari uchun qoladi.

Swift Concurrency: Task, TaskGroup va Actor

Task — Swift-da asinxron ishning asosiy birligi. Task mavjud actor kontekstida yoki ixtiyoriy thread-da yaratiladi. Task ichida async funksiyalar await orqali chaqirilishi mumkin. TaskGroup bir nechta farzand vazifalarni parallel ravishda bajarish va ularning natijalarini to'plash imkonini beradi — bu DispatchGroup ning kuchliroq versiyasi.

Actor — thread-xavfsiz reference type bo'lib, o'z holatini race condition dan himoya qiladi. Kompilyator actor xususiyatlariga faqat async chaqiruvlar yoki actor izolyatsiyasi orqali kirish mumkinligini kafolatlaydi. Actor qo'lda blokirovkalarsiz umumiy o'zgaruvchan holatni himoya qilish uchun serial DispatchQueue o'rnini egallaydi.

Structured Concurrency

Structured Concurrency printsipi: har bir asinxron vazifaning ota-onasi bor va ota-ona barcha farzandlari tugamaguncha tugallanmaydi. Agar A vazifasi Task { await B() } ni ishga tushirsa, A B ni kutadi. Bu vazifa oqishining oldini oladi va bashorat qilinadigan hayotiy siklni ta'minlaydi.

Kotlin-dagi Async/Await korutinlar bilan

Kotlin-da async/await coroutines — tilning yengil thread-lari orqali amalga oshirilgan. Funksiya suspend kalit so'zi bilan belgilanadi (Swift-dagi async ga o'xshash). Ishga tushirish uchun launch (fire-and-forget) yoki async (natija bilan) ishlatiladi. Await async dan natija olish uchun chaqiriladi.

Dispatcher korutin qaysi thread pulida bajarilishini aniqlaydi: Dispatchers.Main UI uchun, Dispatchers.IO tarmoq/disk uchun va Dispatchers.Default CPU intensiv vazifalar uchun. Structured Concurrency CoroutineScope orqali kafolatlanadi — scope bekor qilinganda barcha farzand korutinlar ham bekor qilinadi.

JetBrains ma'lumotlariga ko'ra (2025), Google Play-dagi Android ilovalarining 97% kotlinx.coroutines dan foydalanadi va ulardan 82% tarmoq so'rovlari uchun async/await ni qo'llaydi. Coroutines Android-da asinxron dasturlash uchun de facto standartga aylandi. Kotlin Multiplatform ham coroutines-ni qo'llab-quvvatlaydi, bu Android, iOS va server tomonida umumiy asinxron kodni ishlatish imkonini beradi.

Swift va Kotlin-da Async/Await bilan kod misollari

Har bir til uchun ikkita misolni ko'rib chiqamiz: ketma-ket ma'lumot yuklash va TaskGroup yoki async/await bilan parallel so'rovlar.

Swift: ketma-ket async chaqiruvlari

await foydalanuvchi ma'lumotlari olinmaguncha, keyin do'stlar olinmaguncha bajarilishni to'xtatadi. Uyalangan closure-lar yo'q.

func loadProfile() async throws -> Profile {
    let user = try await api.fetchUser()
    let friends = try await api.fetchFriends(for: user.id)
    return Profile(user: user, friends: friends)
}

Swift: TaskGroup bilan parallel so'rovlar

TaskGroup vazifalarni parallel ravishda bajaradi va natijalarni massivda to'playdi. Natijalar tartibi ishga tushirish tartibiga mos kelmasligi mumkin.

func loadParallel() async throws -> [String] {
    await withThrowingTaskGroup(of: String.self) { group in
        group.addTask { try await api.fetchName() }
        group.addTask { try await api.fetchEmail() }
        group.addTask { try await api.fetchAvatar() }
        var results = [String]()
        for try await value in group { results.append(value) }
        return results
    }
}

Kotlin: async/await bilan ketma-ket chaqiruv

suspend funksiyalari boshqa suspend funksiyalarini chaqirishi mumkin. Swift ga o'xshash: ketma-ket chaqiruvlar.

suspend fun loadProfile(): Profile {
    val user = api.fetchUser()
    val friends = api.fetchFriends(user.id)
    return Profile(user, friends)
}

Kotlin: async/await bilan parallel so'rovlar

Kotlin-da parallellik har bir so'rov uchun async bilan coroutineScope orqali erishiladi.

suspend fun loadParallel(): List<String> = coroutineScope {
    val name = async { api.fetchName() }
    val email = async { api.fetchEmail() }
    val avatar = async { api.fetchAvatar() }
    listOf(name.await(), email.await(), avatar.await())
}

Async/Await-ning odatiy xatolari va cheklovlari

Unutilgan Task { } — asinxron funksiyani Task ga o'ramasdan sinxron kontekstdan chaqirib bo'lmaydi. Swift-da bu kompilyatsiya xatosiga olib keladi. Kotlin-da lifecycleScope yoki viewModelScope orqali ishga tushirish talab qilinadi. Oddiy funksiyadan suspend funksiyasini chaqirish kompilyatsiya qilinmaydi.

Keraksiz async dan ortiqcha foydalanish

Har bir funksiyani asinxron qilish shart emas. I/O siz CPU intensiv vazifalar async dan foyda ko'rmaydi — ularni .userInitiated QoS bilan DispatchQueue da bajarish yaxshiroq. Async/Await I/O bog'liq operatsiyalar uchun optimallashtirilgan: tarmoq, disk, kutish.

.result orqali asosiy thread-ni blokirovka qilish

Asosiy thread-da .result dan foydalanish (async funksiya natijasini sinxron kutish) blokirovkaga olib keladi. Swift-da Task.synchronousWait Apple tomonidan tavsiya etilmaydi. Kotlin-da asosiy thread-da runBlocking antipattern hisoblanadi — lifecycleScope dan foydalaning.

Bekor qilishda Task oqishi

Agar Task sinf xususiyatida saqlanmasa, kontekstdan chiqqandan keyin u bekor qilinadi. Swift-da Task scoped — uning hayotiy sikli yaratuvchi kontekstga bog'langan. Uzoq muddatli operatsiya kerak bo'lganda Task ni xususiyatda saqlang.