Asynchrone Programmierung in Swift: Vollständiger Leitfaden für Anfänger

Einführung in die asynchrone Programmierung in Swift

Moderne mobile und Desktop-Anwendungen müssen reaktionsschnell und schnell sein. Niemand mag es, wenn die Benutzeroberfläche beim Laden von Daten aus dem Netzwerk oder bei der Verarbeitung einer großen Datei einfriert. Genau hier kommt die asynchrone Programmierung ins Spiel. In Swift gibt es seit Version 5.5 ein leistungsstarkes und intuitives Toolkit für die Arbeit mit Asynchronität — async/await, Task und Actor.

In diesem Leitfaden behandeln wir die Grundlagen der asynchronen Programmierung in Swift für iOS und macOS. Sie erfahren, wie Sie asynchronen Code ohne Callbacks (Callback Hell) schreiben, Threads richtig verwalten und Race Conditions vermeiden. Das Material richtet sich an Anfänger, die bereits mit den Grundlagen der Swift-Syntax vertraut sind.

Was ist asynchrone Programmierung und warum wird sie benötigt?

Stellen Sie sich vor, Ihre Anwendung ist ein Koch in der Küche. Wenn der Koch wartet, bis der Wasserkocher kocht, und nichts tut, zieht sich das Mittagessen in die Länge. Asynchrone Programmierung ermöglicht es dem „Koch“ (dem Hauptthread), den Wasserkocher aufzusetzen und, ohne auf das Kochen zu warten, mit dem Schneiden des Salats zu beginnen. Wenn der Wasserkocher kocht, kehrt der Koch zu ihm zurück.

Im Kontext von iOS bedeutet dies, dass schwere Operationen (Bild laden, JSON parsen, Datenbankarbeit) im Hintergrund ausgeführt werden, ohne den Hauptthread zu blockieren, der für die Aktualisierung der Benutzeroberfläche zuständig ist. Wenn dies nicht getan wird, „friert“ die Anwendung ein und wird bald vom System zwangsweise beendet.

Das Problem des alten Ansatzes: Callbacks und GCD

Vor dem Aufkommen von async/await verwendeten Entwickler Grand Central Dispatch (GCD) und Closures (Callbacks). Dies führte zum sogenannten „Callback Hell“ — verschachtelten Codeblöcken, die schwer zu lesen, zu debuggen und zu warten waren.

// Alter Stil mit GCD und Closuresfunc fetchUserData(completion: @escaping (User?) -> Void) {    DispatchQueue.global().async {        // Lange Operation        let user = User(name: "Ivan")        DispatchQueue.main.async {            completion(user)        }    }}

fetchUserData { user in    guard let user = user else { return }    fetchUserPosts(userId: user.id) { posts in        // Noch ein verschachtelter Callback        print(posts)    }}

Modernes Swift bietet eine viel elegantere Lösung.

Grundlagen von Swift Concurrency: async/await

Deklaration einer asynchronen Funktion

Um eine Funktion asynchron zu machen, fügen Sie das Schlüsselwort async nach der Parameterliste hinzu. Um eine solche Funktion aufzurufen, müssen Sie das Schlüsselwort await verwenden.

// Asynchrone Funktionfunc fetchImage(from url: URL) async throws -> UIImage {    let (data, _) = try await URLSession.shared.data(from: url)    guard let image = UIImage(data: data) else {        throw URLError(.badServerResponse)    }    return image}

// Aufruf der FunktionTask {    do {        let image = try await fetchImage(from: url)        self.imageView.image = image    } catch {        print("Fehler beim Laden: \\(error)")    }}

Beachten Sie: URLSession.shared.data(from:) ist bereits eine fertige asynchrone Funktion von Apple. Wir rufen sie einfach mit await auf, und der Thread wird für andere Aufgaben freigegeben, während die Daten geladen werden.

Sequenzielle und parallele Aufrufe

Sie können asynchrone Funktionen sequenziell oder parallel aufrufen.

// Sequenzieller Aufruf: Die zweite Anfrage wartet auf die erstelet user = try await fetchUser(id: 1)let posts = try await fetchPosts(for: user.id)

// Paralleler Aufruf: Beide Anfragen werden gleichzeitig ausgeführtasync let user = fetchUser(id: 1)async let posts = fetchPosts(for: 1)let (resultUser, resultPosts) = try await (user, posts)

Im parallelen Modus werden beide Anfragen gleichzeitig gestartet, was