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

## Mundarija
1. [Nega concurrency kerak? (Motivatsiya)](#motivatsiya)
2. [GCD (Grand Central Dispatch) asoslari](#gcd-asoslari)
3. [DispatchGroup, Semaphore, Barrier](#gcd-advanced)
4. [Async/Await asoslari](#async-await)
5. [Structured Concurrency (TaskGroup, async let)](#structured-concurrency)
6. [Unstructured Concurrency](#unstructured-concurrency)
7. [Actor — Data Race'ni yo'qotish](#actor)
8. [Sendable Protocol](#sendable)
9. [AsyncSequence va AsyncStream](#async-stream)
10. [GCD vs async/await qiyoslash](#comparison)
11. [Thread Explosion muammosi](#thread-explosion)
12. [Real misol: Parallel API yuklash](#real-loyiha)
13. [Xulosa](#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).

```swift
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.

```swift
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.

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

![Task Tree Ierarxiyasi va Avtomatik Bekor Qilish](/lessons/images/concurrency/concurrency_structured_task_tree.svg)

> **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.

```swift
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](/lessons/images/concurrency/concurrency_actor_data_race.svg)

> **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}

| Xususiyat | GCD | async/await |
|-----------|-----|-------------|
| **Sintaksis** | Closure-based | Linear (Tushunarli) |
| **Xatolik** | Callback hell xavfi | Try-catch |
| **Performance** | Thread over-creation | Cooperative threads |

---

## 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](/lessons/images/concurrency/concurrency_thread_explosion_vs_cooperative.svg)

> **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! ⚡