DispatchQueue: bu nima, GCD navbati va ko'p tarmoqlilik asoslari

DispatchQueue va Grand Central Dispatch nima

DispatchQueue — tizim yoki maxsus ip navbatlarida vazifalarning bajarilishini boshqaradigan Grand Central Dispatch (GCD) ramkasining ob'ektidir. Grand Central Dispatch — iOS 4 va macOS 10.6 dan mavjud bo'lgan Apple ning past darajali kutubxonasi bo'lib, u ip boshqaruvini dasturchidan to'liq abstraksiya qiladi. GCD operatsion tizimning ip hovuzidan foydalanadi va qurilma yukiga qarab iplar sonini avtomatik masshtablaydi.

Dasturchi iplarni qo'lda yaratishi va yo'q qilishi shart emas — GCD bu vazifani o'z zimmasiga oladi va DispatchQueue orqali oddiy API taqdim etadi. Vazifa closure (yopilish) shaklida sync yoki async metodlari orqali navbatga yuboriladi. Birinchi holatda chaqiruvchi ip vazifa tugaguncha bloklanadi, ikkinchi holatda esa darhol bajarishni davom ettiradi.

Apple (2026) ma'lumotlariga ko'ra, GCD yadrolar soniga va protsessorning joriy yukiga moslashadigan tizim ip hovuzidan foydalanadi. Concurrent navbat har bir vazifa uchun yangi ip yaratmaydi — GCD hovuzdan iplarni qayta ishlatadi, bu esa ip yaratishdagi qo'shimcha xarajatlarni minimallashtiradi.

GCD arxitekturasi

Grand Central Dispatch uchta asosiy komponentdan iborat: navbat (DispatchQueue), guruh (DispatchGroup) va semafor (DispatchSemaphore). Navbat asosiy element bo'lib, kod bloklari shaklida vazifalarni qabul qiladi. DispatchGroup bir nechta vazifaning bajarilishini sinxronlaydi, DispatchSemaphore esa umumiy resursga ma'lum miqdordagi iplarning kirishini cheklaydi.

Har bir GCD navbati ma'lum bir QoS (Quality of Service) sinfi bilan bog'liq bo'lib, u tizimga vazifaning muhimligi haqida xabar beradi. Tizim QoS dan navbatlar o'rtasida protsessor vaqtini taqsimlash uchun foydalanadi, muhimroq vazifalarga — masalan, UI yangilash yoki foydalanuvchi teginishlarini qayta ishlashga — ustunlik beradi.

Serial va Concurrent navbatlari: taqqoslash

Serial navbat vazifalarni qat'iy ketma-ket, birin-ketin bajaradi. Agar serial navbatga uchta vazifa joylashtirilsa, ikkinchisi faqat birinchisi to'liq tugagandan keyin boshlanadi. Serial navbatlar umumiy resurslarga kirishni sinxronlash uchun ishlatiladi — masalan, kodning bir necha qismidan o'zgartiriladigan massivga kirish.

Concurrent navbat bir nechta vazifani bir vaqtning o'zida bajaradi, ularni tizim hovuzidagi mavjud iplar o'rtasida taqsimlaydi. Concurrent navbatdagi vazifalar kelish tartibida (FIFO) boshlanadi, ammo bajarilish vaqtlari farq qilsa, tasodifiy tartibda tugaydi. Concurrent navbat tugash tartibini kafolatlamaydi — faqat boshlash tartibini kafolatlaydi.

Serial navbatni qachon tanlash kerak

Serial navbat umumiy holatni o'zgartiruvchi vazifalar uchun idealdir — faylga yozish, ma'lumot modelini yangilash yoki Core Data bilan ishlash. Serial navbatdan foydalanish kodning ikki qismi bir vaqtning o'zida bir xil ma'lumotlarni o'zgartirmasligini kafolatlaydi, qo'shimcha blokirovkalarsiz poyga holatini bartaraf etadi.

Concurrent navbatni qachon tanlash kerak

Concurrent navbat bir-biriga bog'liq bo'lmagan vazifalar uchun mos keladi: bir nechta rasmni yuklash, parallel tarmoq so'rovlari yoki ma'lumotlarni guruhli qayta ishlash. GCD protsessor yadrolari soni va tizimning joriy yukiga qarab bir vaqtning o'zida nechta vazifani ishga tushirishni avtomatik hal qiladi.

Quality of Service: vazifalarni bajarish ustuvorliklari

QoS (Quality of Service) — operatsion tizimga vazifaning muhimligi va shoshilinchligi haqida xabar beruvchi GCD mexanizmi. Tizim iplarni rejalashtirish uchun QoS dan foydalanadi: yuqori QoS ga ega vazifalar ko'proq protsessor vaqti oladi va ertaroq ishga tushiriladi. QoS qiymati navbat yaratishda yoki muayyan vazifani yuborishda uzatiladi.

GCD da beshta QoS sinfi mavjud. .userInteractive — UI bilan bog'liq vazifalar uchun eng yuqori ustuvorlik. .userInitiated — foydalanuvchi tomonidan boshlangan vazifalar uchun. .utility — taraqqiyot ko'rsatiladigan fon vazifalari uchun. .background — foydalanuvchiga ko'rinmaydigan vazifalar uchun. .default — userInitiated va utility o'rtasidagi oraliq daraja, standart sifatida ishlatiladi.

Apple (2026) ma'lumotlariga ko'ra, QoS ni noto'g'ri tanlash samaradorlik muammolarining tez-tez uchraydigan sabablaridan biridir. QoS .userInteractive bilan fon yuklashni ishga tushirish UI dan resurslarni oladi, animatsiyalarda mikro-laglarga sabab bo'ladi. Qabul qilinadigan bajarish vaqtini ta'minlaydigan eng past QoS ni tanlash tavsiya etiladi.

QoS ni qo'llash misoli

Darhol ko'rsatish uchun rasm yuklanayotganda .userInitiated dan foydalaning — foydalanuvchi natijani kutadi. Keyingi ekranni oldindan yuklash uchun .utility yetarli. Server bilan fon sinxronizatsiyasi .background bilan bajariladi, faol vazifalarga ta'sirni minimallashtiradi.

DispatchGroup va semaforlar: vazifalarni sinxronlash

DispatchGroup bir guruh vazifalarning tugashini kuzatish imkonini beradi. Guruhdagi barcha vazifalar tugagach, GCD belgilangan navbatda notify handler ni chaqiradi. Bu bir nechta mustaqil resurslar — profil ma'lumotlari, do'stlar ro'yxati va sozlamalar yuklanayotganda, interfeys faqat barcha ma'lumotlar olingandan keyin yangilanishi kerak bo'lganda ayniqsa foydali.

DispatchGroup sinxron chaqiruv wait() ni qo'llab-quvvatlaydi, u barcha vazifalar tugaguncha joriy ipni bloklaydi. Bu kod guruh natijalarisiz davom etolmaydigan hollarda qulay. Asinxron variant — notify() — barcha vazifalar tugagandan so'ng belgilangan navbatda closure ni chaqiradi, chaqiruvchi ipni bloklamasdan.

Parallellikni cheklash uchun DispatchSemaphore

DispatchSemaphore resursga kirishni boshqaradi, bir vaqtning o'zida kirishlar sonini cheklaydi. Boshlang'ich qiymati 3 bo'lgan semafor uchdan ortiq bo'lmagan parallel vazifani ishga tushirishga imkon beradi. wait() chaqirilganda hisoblagich kamayadi, signal() chaqirilganda esa ortadi. Hisoblagich nolga teng bo'lsa, ip resurs bo'shaguncha bloklanadi.

Swift da DispatchQueue bilan kod namunalari

Swift da DispatchQueue dan foydalanishning uchta amaliy misolini ko'rib chiqamiz. Birinchisi asosiy async chaqiruvni asosiy ipga qaytish bilan ko'rsatadi, ikkinchisi — serial navbat orqali sinxronlashni, uchinchisi — parallel so'rovlar uchun DispatchGroup ni.

Main ga qaytish bilan asosiy async chaqiruv

DispatchQueue.main — asosiy ipning serial navbati bo'lib, faqat UI operatsiyalari uchun mo'ljallangan. Fon ishi tugagandan so'ng interfeysni yangilash uchun har doim undan foydalaning.

let queue = DispatchQueue.global(qos: .userInitiated)
queue.async {
    let data = self.fetchData()
    DispatchQueue.main.async {
        self.updateUI(with: data)
    }
}

Umumiy resursni himoya qilish uchun serial navbat

Noyob identifikator bilan o'z serial navbatingizni yaratish o'zgaruvchan massivga kirishni sinxronlashtiradi. Barcha o'qish va yozish operatsiyalari bitta navbatdan o'tadi, poyga holatini bartaraf etadi.

let serialQueue = DispatchQueue(label: "com.app.items")
var items: [Int] = []

serialQueue.async {
    items.append(1)
}
serialQueue.async {
    let last = items.last
    DispatchQueue.main.async {
        print("Last item: \(last)")
    }
}

Parallel so'rovlar uchun DispatchGroup

DispatchGroup concurrent navbatda bir nechta vazifani ishga tushirish va barchasining tugashi haqida xabarnoma olish imkonini beradi. Bu profil ekrani uchun ma'lumotlarni yuklashda foydalidir.

let group = DispatchGroup()
let worker = DispatchQueue.global()

worker.async(group: group) { self.loadProfile() }
worker.async(group: group) { self.loadFriends() }
worker.async(group: group) { self.loadSettings() }

group.notify(queue: DispatchQueue.main) {
    self.showCompleteUI()
}

DispatchQueue bilan ishlashda odatiy xatolar

Deadlock serial navbatda sync chaqiruvi paytida — eng keng tarqalgan xato. Agar serial navbatdagi vazifa xuddi shu navbatda queue.sync ni chaqirsa, ip abadiy bloklanadi. Navbat joriy vazifaning tugashini kutadi, vazifa esa sync chaqiruvining tugashini kutadi — klassik o'zaro blokirovka.

Fon ipidan UI ni yangilash

UIKit bilan barcha operatsiyalar asosiy ipda bajarilishi kerak. Xcode Debug rejimida Main Thread Checker orqali bu xatolarni aniqlaydi. Release yig'ilishida ular oldindan aytib bo'lmaydigan xatti-harakatlarga olib keladi: animatsiyalar ishga tushmaydi, UI yangilanmaydi, crash lar mumkin.

Haddan tashqari ko'p maxsus navbatlar yaratish

Global navbatlar o'rniga yuzlab maxsus navbatlarni yaratish — anti-namuna. Har bir navbat tizim resurslarini iste'mol qiladi. Aksariyat vazifalar uchun turli QoS bilan global concurrent navbatlar va umumiy ma'lumotlarni sinxronlash uchun bir-ikki serial navbat yetarli.

Sikllarda autoreleasepool ni e'tiborsiz qoldirish

autoreleasepool holda fon navbatida resurs talab qiladigan tsiklik vazifalarni bajarishda xotira butun sikl tugaguniga qadar o'sadi. ARC obyektlarni faqat autorelease pool dan chiqishda bo'shatadi. Sikl iteratsiyalarini o'z vaqtida xotira bo'shatish uchun autoreleasepool { } ichiga joylashtiring.