Concurrency — async/await

Darsliklar (Tutorials)

Concurrency — async/await, Actor — To'liq Darslik

Mundarija

1. Nega concurrency kerak? (Motivatsiya)
2. GCD (Grand Central Dispatch) asoslari
3. DispatchGroup, Semaphore, Barrier
4. Async/Await asoslari
5. Structured Concurrency (TaskGroup, async let)
6. Unstructured Concurrency
7. Actor — Data Race'ni yo'qotish
8. Sendable Protocol
9. AsyncSequence va AsyncStream
10. GCD vs async/await qiyoslash
11. Thread Explosion muammosi
12. Real misol: Parallel API yuklash
13. Xulosa

1. Nega concurrency kerak? (Motivatsiya) {#motivatsiya}

Ilovangiz bir vaqtda faqat bitta ishni bajara olsa, u juda sekin va zerikarli bo'lib qoladi.

• Main Thread (UI thread): Faqat interfeysni chizish uchun ishlatilishi kerak. Agar bu yerda og'ir hisob-kitob yoki API chaqiruv qilsangiz, ilova "qotib" (freeze) qoladi.
• Concurrency: Bir vaqtning o'zida ham rasm yuklash, ham foydalanuvchi bilan muloqot qilish imkonini beradi.

2. GCD (Grand Central Dispatch) asoslari {#gcd-asoslari}

GCD — bu Apple'ning eski, lekin hali ham ishlatiladigan concurrency tizimi. U "Queue" (navbat) asosida ishlaydi.

• Main Queue: UI uchun.
• Global Queue: Orqa fon ishlari uchun (QoS darajalari bilan: userInteractive, userInitiated, utility, background).

DispatchQueue.global().async {
    // Og'ir ish (background)
    DispatchQueue.main.async {
        // UI ni yangilash
    }
}

3. DispatchGroup, Semaphore, Barrier {#gcd-advanced}

• DispatchGroup: Bir nechta asinxron ishlar tugashini kutish uchun.
• Semaphore: Bir vaqtda ma'lum bir resursga nechta thread kira olishini cheklash.
• Barrier: Read/Write muammolarini hal qilish uchun (faqat bittasini o'tkazish).

4. Async/Await asoslari {#async-await}

Swift 5.5 da taqdim etilgan yangi va qulayroq tizim. Kod xuddi sinxron kabi toza o'qiladi.

func fetchUserData() async throws -> User {
    let url = URL(string: "https://api.com/user")!
    let (data, _) = try await URLSession.shared.data(from: url)
    return try JSONDecoder().decode(User.self, from: data)
}

5. Structured Concurrency (TaskGroup, async let) {#structured-concurrency}

Bir nechta ishlarni parallel va tartibli bajarish.

• async let: Bir vaqtda ikkita o'zgarmasni yuklash.
• TaskGroup: Noaniq miqdordagi ishlarni parallel bajarish.

async let user = fetchUser()
async let posts = fetchPosts()
let result = try await (user, posts) // Ikkalasi parallel yuklanadi

Task Tree Ierarxiyasi va Avtomatik Bekor Qilish

Kaskadli bekor qilish (Cancellation Propagation): Structured concurrency'da barcha async let va TaskGroup vazifalari daraxtsimon ierarxiyada bog'lanadi. Agar bolalardan biri xato tashlasa yoki ota task bekor qilinsa, qolgan barcha parallel bolalar bir zumda to'xtatiladi. Natijada xotirada "yetim" (orphan) jarayonlar qolmaydi.

6. Unstructured Concurrency {#unstructured-concurrency}

Ba'zan asinxron ishni qayerdadir "shunchaki boshlab yuborish" kerak bo'ladi (ota-bola munosabatisiz). Buning uchun Task ishlatiladi.

7. Actor — Data Race'ni yo'qotish {#actor}

Reference turlar bilan ishlaganda (Class) bir vaqtda bir nechta thread bitta ma'lumotni o'zgartirsa (Data Race), ilova crash bo'ladi. Actor buni avtomatik hal qiladi.

actor ScoreBoard {
    var score = 0
    func add() { score += 1 } // Xavfsiz!
}

@MainActor // UI ishlari uchun maxsus actor
class ViewModel: ObservableObject { ... }

Data Race Xavfi vs Swift Actor Izolyatsiyasi

Swift 6 Kompilyator Kafolati: Actor o'z ichki holatini "Mailbox" (navbat) orqali himoya qiladi. Har qanday vaqtda actor ichida faqat bitta Task ishlay oladi, qolganlari esa await bilan o'z navbatini kutadi. Swift 6 da actor holatiga await siz kirishga urinsangiz kod hatto kompilyatsiya ham bo'lmaydi!

8. Sendable Protocol {#sendable}

Thread'lar o'rtasida xavfsiz o'tkazish mumkin bo'lgan turlar (Value types — struct, enum).

9. AsyncSequence va AsyncStream {#async-stream}

Xuddi massiv kabi, lekin elementlar vaqt o'tishi bilan "asinxron" keladi.

10. GCD vs async/await qiyoslash {#comparison}

11. Thread Explosion muammosi {#thread-explosion}

GCD da minglab thread yaratilsa, tizim CPU ni almashtirish bilan band bo'lib qoladi. Modern Swift Concurrency-da esa threadlar soni CPU yadrolari soniga qarab cheklanadi.

GCD Thread Explosion vs Swift Cooperative Thread Pool

Cooperative Thread Pool: GCD da har bir bloklangan navbat uchun yangi operatsion tizim oqimi ochilardi (100 ta bloklangan so'rov = 100 ta OS thread). Swift Concurrency esa CPU yadrolari soniga teng (4-8 ta) doimiy oqimlar hovuzidan foydalanadi. await chaqirilganda OS oqimi qotib turmaydi, balki suspend holatiga o'tib, ipni darhol boshqa Task'larga bo'shatib beradi.

12. Real misol: Parallel API yuklash {#real-loyiha}

Darslikda biz bir vaqtning o'zida profil rasmi, obunalar va yangiliklarni parallel yuklab, hammasi tayyor bo'lgandagina UI'ni chiqarishni o'rganamiz.

13. Xulosa {#xulosa}

Modern Swift Concurrency — bu iOS devning eng muhim ko'nikmasidir.

• async/await ni o'rganish sizning kodingizni toza qiladi.
• Actor larni tushunish sizni crash'lardan qutqaradi.

Vazifa: TaskGroup yordamida bir nechta URL dagi rasmlarni parallel yuklovchi funksiya yozib ko'ring! ⚡