Antwort.

Geschichtlicher Hintergrund

Grand Central Dispatch (GCD) kam 2009 in iOS und macOS als Low-Level-System zur Organisation von konkurrierendem, asynchronem Code (Multithreading) auf Basis von Warteschlangen – DispatchQueue. GCD stellte sich als viel prägnanter heraus als die manuelle Verwaltung von Threads und bietet eine sichere Ausführung von Aufgaben, Synchronisierung und eine benutzerfreundliche API.

Problem

Asynchronität und Multithreading sind traditionell die Quelle der meisten Probleme: Datenrennen, Deadlocks, UI-Hänger und komplexe Abstürze. Falsche Verwendung von Warteschlangen oder Versuche, auf das UI aus einem Nicht-Haupt-Thread zuzugreifen, führen zu Bugs.

Lösung

Swift ermöglicht es, Hintergrundarbeiten einfach zu erstellen und sicher auf den Haupt-Thread zurückzukehren, um die Benutzeroberfläche mit globalen und benutzerdefinierten Warteschlangen zu aktualisieren. Verwenden Sie DispatchQueue für asynchrone Arbeiten und DispatchGroup, wenn Sie auf den Abschluss einer Gruppe von asynchronen Aufgaben warten müssen.

Codebeispiel:

let backgroundQueue = DispatchQueue(label: "background", qos: .background)
backgroundQueue.async {
    // läuft im Hintergrund-Thread
    let image = downloadImage()
    DispatchQueue.main.async {
        // sicheres Update des UI
        imageView.image = image
    }
}

Wichtige Merkmale:

DispatchQueue.async führt einen Block asynchron aus
DispatchQueue.main.async für Aufrufe im Haupt-Thread
DispatchSemaphore, DispatchGroup, sync sowie qos zur Kontrolle von Aufgabenprioritäten

Fragen mit Überraschungen.

Was passiert, wenn man sync auf der Hauptwarteschlange aus dem Haupt-Thread aufruft?

Es kommt zu einem Deadlock: Der Haupt-Thread wartet auf die Ausführung einer Aufgabe auf sich selbst, und die Anwendung "hängt".

DispatchQueue.main.sync {
    // DEADLOCK
}

Kann DispatchQueue.serial Aufgaben parallel ausführen?

Nein, die serielle Warteschlange führt Aufgaben immer nacheinander aus, aber wenn mehrere serielle Warteschlangen erstellt werden, laufen sie parallel zueinander.

Ist es erlaubt, das UI nicht aus dem Haupt-Thread zu aktualisieren?

Nein, alle Manipulationen mit UIKit (oder SwiftUI View Rendering) können nur aus DispatchQueue.main durchgeführt werden. Ein Verstoß führt zu instabiler Funktionalität und Abstürzen.

Typische Fehler und Anti-Pattern

Synchroner Aufruf im Haupt-Thread (Deadlock)
Versuch, das UI im Hintergrund zu aktualisieren
Unkontrolliertes Ressourcenrennen beim Schreiben in gemeinsame Variablen
Verwendung der globalen Warteschlange ohne Notwendigkeit, keine dedizierten Warteschlangen

Beispiel aus dem Leben

Negativer Fall

Im Hintergrund-Thread werden Daten geladen, sofort das UI aktualisiert – die Anwendung stürzt gelegentlich ab oder die Benutzeroberfläche hängt. Zudem wird Shared Mutable State zwischen Threads ohne Synchronisation verwendet.

Vorteile:

Der Code ist visuell prägnant

Nachteile:

Instabile Bugs und selten reproduzierbare Abstürze
Leistungseinbußen

Positiver Fall

Organisation aller UI-Updates ausschließlich auf DispatchQueue.main, dedizierte Warteschlangen für die Arbeit mit großen Datenmengen, Verwendung von DispatchGroup zur Kontrolle des Abschlusses asynchroner Aufgaben.