Antwoord.

Geschiedenis van de vraag

Grand Central Dispatch (GCD) kwam in 2009 naar iOS en macOS als een low-level systeem voor het organiseren van concurrerende, asynchrone code (multithreading), gebaseerd op queues — DispatchQueue. GCD bleek veel beknopter dan handmatig beheer van threads, en zorgde voor veilige uitvoering van taken, synchronisatie en een gebruiksvriendelijke API.

Probleem

Asynchroniciteit en multithreading zijn traditioneel de bron van de meeste problemen: data races, deadlocks, bevroren interfaces en complexe crashes. Onjuist gebruik van queues of pogingen om naar de UI te verwijzen vanuit een niet-hoofdthread leiden tot bugs.

Oplossing

Swift maakt het gemakkelijk om achtergrondwerk te creëren en veilig terug te keren naar de hoofdthread voor het bijwerken van de interface met behulp van globale en aangepaste queues. Gebruik DispatchQueue voor asynchrone taken en DispatchGroup als je wilt wachten op de voltooiing van een set asynchrone taken.

Codevoorbeeld:

let backgroundQueue = DispatchQueue(label: "background", qos: .background)
backgroundQueue.async {
    // uitgevoerd op een achtergrondthread
    let image = downloadImage()
    DispatchQueue.main.async {
        // veilige interface-update
        imageView.image = image
    }
}

Kernfunctionaliteiten:

DispatchQueue.async voert een blok asynchroon uit
DispatchQueue.main.async voor aanroep op de hoofdthread
DispatchSemaphore, DispatchGroup, sync, evenals qos voor controle van taakprioriteit

Vragen met valkuilen.

Wat gebeurt er als je sync op de hoofdqueue aanroept vanuit de hoofdthread?

Er zal een deadlock optreden: de hoofdthread wacht op de uitvoering van een taak op zichzelf, en de applicatie "bevriest".

DispatchQueue.main.sync {
    // DEADLOCK
}

Kan DispatchQueue.serial taken parallel uitvoeren?

Nee, een seriële queue voert altijd taken één voor één uit, maar als je meerdere seriële queues aanmaakt, worden deze parallel tussen elkaar uitgevoerd.

Is het toegestaan om de interface bij te werken vanuit een niet-hoofdthread?

Nee, alle manipulaties met UIKit (of SwiftUI View rendering) mogen alleen worden gedaan vanuit DispatchQueue.main. Het overtreden hiervan leidt tot instabiliteit en crashes.

Typische fouten en anti-patronen

Synchronisatie aanroep op de hoofdthread (deadlock)
Pogingen om de UI vanuit de achtergrond bij te werken
Ongecontroleerde race conditions bij schrijven naar gedeelde variabelen
Gebruik van globale queue zonder noodzaak, ontbreken van toegewezen queues

Leefsevoorbeeld

Negatieve case

Data wordt geladen op een achtergrondthread, en de UI wordt onmiddellijk bijgewerkt — de applicatie crasht soms of de interface bevriest. Bovendien wordt gedeelde veranderlijke toestand tussen threads gebruikt zonder synchronisatie.

Voordelen:

Code is visueel beknopt

Nadelen:

Onstabiele bugs en zelden reproduceerbare crashes
Verlies van prestaties

Positieve case

Organiseren van alle UI-updates uitsluitend op DispatchQueue.main, toegewezen queues voor werken met grote gegevens, gebruik van DispatchGroup voor controle over de voltooiing van asynchrone taken.