Swift Aufgabenplaner (iOS/macOS): GCD, OperationQueue…

Swift Aufgabenplaner (iOS/macOS): GCD, OperationQueue und Timer

In der Entwicklung für iOS und macOS sind die Verwaltung asynchroner Aufgaben, verzögerter Ausführungen und Multithreading die Grundlage für Leistung und Reaktionsfähigkeit von Anwendungen. In Swift werden dafür drei Schlüsselkomponenten verwendet: GCD (Grand Central Dispatch), OperationQueue und Timer. In diesem Artikel werden wir jede davon im Detail analysieren, Codebeispiele zeigen und erklären, wann was anzuwenden ist.

1. Grand Central Dispatch (GCD) — DispatchQueue

GCD ist eine Low-Level C-API, die Swift über DispatchQueue bereitstellt. Sie ermöglicht die asynchrone, parallele oder serielle Ausführung von Aufgaben und verwaltet Threads automatisch.

Grundlegende Warteschlangentypen:

Main Queue — serielle Warteschlange, führt Aufgaben auf dem Hauptthread aus (UI).
Global Queues — parallele Warteschlangen mit unterschiedlichen Prioritäten (background, user-initiated, utility).
Custom Serial/Concurrent Queues — werden vom Entwickler erstellt.

Beispiel: Asynchrones Laden von Daten

import Foundation

// Holen der globalen HintergrundwarteschlangeDispatchQueue.global(qos: .background).async {    // Schwere Arbeit (Parsing, Download)    let data = try? Data(contentsOf: URL(string: "https://example.com/data.json")!)        // Rückkehr zum Hauptthread für UI-Updates    DispatchQueue.main.async {        // Aktualisieren der Benutzeroberfläche        print("Daten geladen: \\(data?.count ?? 0) Bytes")    }}

Verzögerte Ausführung (dispatch_after)

let deadline = DispatchTime.now() + 3.0 // nach 3 SekundenDispatchQueue.main.asyncAfter(deadline: deadline) {    print("3 Sekunden vergangen")}

Aufgabengruppen (DispatchGroup)

let group = DispatchGroup()

group.enter()DispatchQueue.global().async {    // Aufgabe 1    Thread.sleep(forTimeInterval: 2)    group.leave()}

group.enter()DispatchQueue.global().async {    // Aufgabe 2    Thread.sleep(forTimeInterval: 1)    group.leave()}

// Benachrichtigung über Abschluss aller Aufgabengroup.notify(queue: .main) {    print("Alle Aufgaben abgeschlossen")}

2. OperationQueue — Hochwertiger Planer

OperationQueue ist auf GCD aufgebaut, bietet aber mehr Flexibilität: Abhängigkeiten zwischen Operationen, Prioritäten, Abbruch einzelner Aufgaben, Begrenzung der maximalen Anzahl paralleler Operationen.

Erstellen und Ausführen von Operationen

let queue = OperationQueue()queue.maxConcurrentOperationCount = 2 // maximal 2 parallele Aufgaben

let operation1 = BlockOperation {    print("Operation 1")    Thread.sleep(forTimeInterval: 1)}

let operation2 = BlockOperation {    print("Operation 2")    Thread.sleep(forTimeInterval: 1)}

// Abhängigkeit festlegen: operation2 beginnt erst nach operation1operation2.addDependency(operation1)

queue.addOperations([operation1, operation2], waitUntilFinished: false)

Abbrechen von Operationen

operation1.cancel() // Bricht die Operation ab, wenn sie noch nicht ausgeführt wird

// Prüfung auf Abbruch innerhalb der Operationlet cancellableOp = BlockOperation {    if !cancellableOp.isCancelled {        print("Werde ausgeführt")    }}

Wesentliche Merkmale von OperationQueue:

Es kann qualityOfService (Priorität) festgelegt werden.
Operationen können Operation-Objekte mit überschriebener main()-Methode sein.
Unterstützt KVO (Key-Value Observing) zur Zustandsüberwachung.