Asynchronous Programming in Swift: A Complete Guide for Beginners

Introduction to Asynchronous Programming in Swift

Modern mobile and desktop applications must be responsive and fast. Nobody likes it when the interface freezes while loading data from the network or processing a large file. This is where asynchronous programming comes to the rescue. In Swift, starting from version 5.5, a powerful and intuitive toolkit for working with asynchrony has appeared — async/await, Task, and Actor.

In this guide, we will cover the basics of asynchronous programming in Swift for iOS and macOS. You will learn how to write asynchronous code without callbacks (callback hell), properly manage threads, and avoid race conditions. The material is designed for beginner developers who are already familiar with the basics of Swift syntax.

What is asynchronous programming and why is it needed?

Imagine your application is a chef in a kitchen. If the chef waits for the kettle to boil and does nothing else, dinner will be delayed. Asynchronous programming allows the "chef" (main thread) to put the kettle on and, without waiting for it to boil, start chopping a salad. When the kettle boils, the chef will return to it.

In the context of iOS, this means that heavy operations (loading an image, parsing JSON, working with a database) are performed in the background, without blocking the main thread, which is responsible for updating the interface. If this is not done, the application will "freeze" and will soon be forcibly closed by the system.

The problem with the old approach: callbacks and GCD

Before the advent of async/await, developers used Grand Central Dispatch (GCD) and closures (callbacks). This led to the so-called "callback hell" — nested blocks of code that were difficult to read, debug, and maintain.

// Old style with GCD and closuresfunc fetchUserData(completion: @escaping (User?) -> Void) {    DispatchQueue.global().async {        // Long 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        // Another nested callback        print(posts)    }}

Modern Swift offers a much more elegant solution.

Basics of Swift Concurrency: async/await

Declaring an asynchronous function

To make a function asynchronous, add the keyword async after the parameter list. To call such a function, you need to use the keyword await.

// Asynchronous functionfunc 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}

// Calling the functionTask {    do {        let image = try await fetchImage(from: url)        self.imageView.image = image    } catch {        print("Loading error: \\(error)")    }}

Note: URLSession.shared.data(from:) is already a ready-made asynchronous function from Apple. We simply call it with await, and the thread is freed for other tasks while the data is being loaded.

Sequential and parallel calls

You can call asynchronous functions sequentially or in parallel.

// Sequential call: the second request waits for the firstlet user = try await fetchUser(id: 1)let posts = try await fetchPosts(for: user.id)

// Parallel call: both requests execute simultaneouslyasync let user = fetchUser(id: 1)async let posts = fetchPosts(for: 1)let (resultUser, resultPosts) = try await (user, posts)

In parallel mode, both requests start simultaneously, which