DispatchQueue: ce este, coada GCD și elementele de bază ale multi-threading-ului

Ce este DispatchQueue și Grand Central Dispatch

DispatchQueue este un obiect al framework-ului Grand Central Dispatch (GCD) care gestionează execuția sarcinilor în cozi de thread-uri sistemice sau personalizate. Grand Central Dispatch este o bibliotecă de nivel scăzut Apple, disponibilă din iOS 4 și macOS 10.6, care abstractizează complet gestionarea thread-urilor de la dezvoltator. GCD utilizează pool-ul de thread-uri al sistemului de operare și scalează automat numărul de thread-uri sub încărcarea dispozitivului.

Dezvoltatorul nu trebuie să creeze și să distrugă manual thread-uri — GCD preia această sarcină, oferind un API simplu prin DispatchQueue. Sarcina sub formă de closure (închidere) este trimisă în coadă prin metodele sync sau async. În primul caz, thread-ul apelant este blocat până la finalizarea sarcinii, în al doilea — continuă execuția imediat.

Conform Apple (2026), GCD utilizează pool-ul de thread-uri al sistemului care se adaptează la numărul de nuclee și încărcarea curentă a procesorului. Coada concurrent nu creează un nou thread pentru fiecare sarcină — GCD reutilizează thread-urile din pool, ceea ce minimizează costurile suplimentare ale creării thread-urilor.

Arhitectura GCD

Grand Central Dispatch constă din trei componente cheie: coada (DispatchQueue), grupul (DispatchGroup) și semaforul (DispatchSemaphore). Coada este elementul principal care primește sarcini sub formă de blocuri de cod. DispatchGroup sincronizează execuția mai multor sarcini, iar DispatchSemaphore limitează accesul la o resursă comună la un număr specificat de thread-uri.

Fiecare coadă GCD este asociată cu o anumită clasă QoS (Quality of Service) care informează sistemul despre importanța sarcinii. Sistemul utilizează QoS pentru distribuirea timpului de procesor între cozi, acordând prioritate sarcinilor mai critice — de exemplu, actualizarea UI sau procesarea atingerilor utilizatorului.

Cozile Serial și Concurrent: comparație

Coada Serial execută sarcinile strict secvențial, una după alta. Dacă în coada serial sunt plasate trei sarcini, a doua începe doar după finalizarea completă a primei. Cozile serial sunt utilizate pentru sincronizarea accesului la resurse comune — de exemplu, la un tablou care este modificat din mai multe părți ale codului.

Coada Concurrent rulează mai multe sarcini simultan, distribuindu-le între thread-urile disponibile din pool-ul sistemului. Sarcinile pe o coadă concurrent pornesc în ordinea sosirii (FIFO), dar se finalizează într-o ordine arbitrară dacă timpul lor de execuție diferă. Coada Concurrent nu garantează ordinea finalizării — doar ordinea pornirii.

Când să alegeți coada serial

Coada serial este ideală pentru sarcinile care modifică starea comună — scrierea în fișier, actualizarea modelului de date sau lucrul cu Core Data. Utilizarea cozii serial garantează că două bucăți de cod nu vor modifica aceleași date simultan, eliminând starea de cursă fără blocări suplimentare.

Când să alegeți coada concurrent

Coada Concurrent este potrivită pentru sarcinile independente una de alta: încărcarea mai multor imagini, cereri de rețea paralele sau procesarea în lot a datelor. GCD decide automat câte sarcini să ruleze simultan, pe baza numărului de nuclee ale procesorului și a încărcării curente a sistemului.

Quality of Service: prioritățile de execuție a sarcinilor

QoS (Quality of Service) — mecanismul GCD care informează sistemul de operare despre importanța și urgența sarcinii. Sistemul utilizează QoS pentru planificarea thread-urilor: sarcinile cu QoS mai ridicat primesc mai mult timp de procesor și sunt pornite mai devreme. Valoarea QoS este transmisă la crearea cozii sau la trimiterea unei sarcini specifice.

În GCD sunt disponibile cinci clase QoS. .userInteractive — cea mai înaltă prioritate pentru sarcinile legate de UI. .userInitiated — pentru sarcinile inițiate de utilizator. .utility — pentru sarcinile de fundal cu afișarea progresului. .background — pentru sarcinile invizibile utilizatorului. .default — nivelul intermediar între userInitiated și utility, utilizat implicit.

Conform Apple (2026), alegerea incorectă a QoS este una dintre cauzele frecvente ale problemelor de performanță. Pornirea încărcării de fundal cu QoS .userInteractive fură resurse de la UI, provocând micro-întârzieri în animații. Se recomandă alegerea celui mai scăzut QoS care asigură în continuare un timp de execuție acceptabil.

Exemplu de aplicare a QoS

La încărcarea unei imagini pentru afișarea imediată, utilizați .userInitiated — utilizatorul așteaptă rezultatul. Pentru preîncărcarea următoarei ecrane este suficient .utility. Sincronizarea de fundal cu serverul se execută cu .background, minimizând impactul asupra sarcinilor active.

DispatchGroup și semafoare: sincronizarea sarcinilor

DispatchGroup permite urmărirea finalizării unui grup de sarcini. Când toate sarcinile din grup sunt finalizate, GCD apelează handler-ul notify pe coada specificată. Acest lucru este util în special la încărcarea mai multor resurse independente — datele profilului, lista de prieteni și setări, când interfața trebuie actualizată doar după primirea tuturor datelor.

DispatchGroup suportă apelul sincron wait() care blochează thread-ul curent până la finalizarea tuturor sarcinilor. Acest lucru este convenabil când codul nu poate continua fără rezultatele grupului. Varianta asincronă — notify() — apelează closure-ul pe coada specificată după finalizarea tuturor sarcinilor, fără a bloca thread-ul apelant.

DispatchSemaphore pentru limitarea paralelismului

DispatchSemaphore controlează accesul la o resursă, limitând numărul de accesări simultane. Un semafor cu valoarea inițială 3 permite rularea a cel mult trei sarcini paralele. La apelul wait() contorul scade, la signal() — crește. Dacă contorul este zero, thread-ul este blocat până la eliberarea resursei.

Exemple de cod cu DispatchQueue în Swift

Să analizăm trei exemple practice de utilizare a DispatchQueue în Swift. Primul demonstrează apelul async de bază cu revenirea pe thread-ul principal, al doilea — sincronizarea printr-o coadă serial, al treilea — DispatchGroup pentru cereri paralele.

Apel async de bază cu revenirea pe main

DispatchQueue.main este coada serial a thread-ului principal, destinată exclusiv operațiilor UI. Utilizați-o întotdeauna pentru actualizarea interfeței după finalizarea lucrului în fundal.

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

Coada serial pentru protecția resursei comune

Crearea propriei cozi serial cu un identificator unic sincronizează accesul la un tablou modificabil. Toate operațiile de citire și scriere trec printr-o singură coadă, eliminând starea de cursă.

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)")
    }
}

DispatchGroup pentru cereri paralele

DispatchGroup permite rularea mai multor sarcini pe o coadă concurrent și primirea unei notificări la finalizarea tuturor. Acest lucru este util la încărcarea datelor pentru ecranul de profil.

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()
}

Erori tipice la lucrul cu DispatchQueue

Deadlock la apelul sync pe o coadă serial — cea mai frecventă eroare. Dacă o sarcină pe o coadă serial apelează queue.sync pe aceeași coadă, thread-ul se blochează permanent. Coada așteaptă finalizarea sarcinii curente, iar sarcina așteaptă finalizarea apelului sync — o blocare mutuală clasică.

Actualizarea UI de pe un thread de fundal

Toate operațiile cu UIKit trebuie executate pe thread-ul principal. Xcode detectează aceste erori în Debug prin Main Thread Checker. În compilarea Release, ele duc la un comportament imprevizibil: animațiile nu pornesc, UI nu se actualizează, sunt posibile crash-uri.

Crearea excesivă a cozilor personalizate

Crearea a sute de cozi personalizate în locul cozilor globale — antipatern. Fiecare coadă consumă resurse ale sistemului. Pentru majoritatea sarcinilor sunt suficiente cozile globale concurrent cu QoS diferit și una-două cozi serial pentru sincronizarea datelor partajate.

Ignorarea autoreleasepool în bucle

La executarea sarcinilor ciclice consumatoare de resurse pe o coadă de fundal fără autoreleasepool, memoria crește până la finalizarea întregii bucle. ARC eliberează obiectele doar la ieșirea din autorelease pool. Înconjurați iterațiile buclei în autoreleasepool { } pentru eliberarea la timp a memoriei.