Embracing the Future with Swift Concurrency: A Comprehensive Overview

As seasoned iOS developers, we are familiar with the challenges of writing robust and efficient concurrent code. Before Swift 5.5, we leaned on tools like PromisesKit, RxSwift, or Grand Central Dispatch (GCD) to handle asynchronous programming, often leading to “callback hell” or convoluted code architectures. However, with the introduction of Swift concurrency, we’re taking a giant leap towards simpler, safer, and more efficient concurrent code.

Unraveling the Problem: The “Callback Hell”

Consider a simple, but common, scenario in app development: You need to fetch user data from a server, then fetch additional information based on that user data, and finally update the UI.

With PromisesKit or RxSwift, we might handle it like this:

The code does its job, but we are entangling our business logic with asynchronous handling code, making it hard to read, maintain, and debug.

Swift’s Solution: Async/Await

Swift 5.5 introduces async/await, significantly streamlining asynchronous code. Let’s see how we would handle the previous scenario with Swift’s async/await:

With async/await, the asynchronous code now appears almost identical to synchronous code. This straight-line coding style enhances readability, maintainability, and reduces cognitive overload.

Encapsulating State: The Actor Model

Concurrency bugs often arise due to shared mutable state across threads. In the past, we’ve used GCD or locks to control access to shared resources, but this approach can lead to issues like deadlocks and race conditions.

Swift 5.5 introduces actors, a new way to protect shared mutable state. An actor is a type that protects access to its own internal state. Let’s look at an example:

In this case, `value` is protected inside the `Counter` actor. All access to `value` is serialized, preventing race conditions.

Coordinating Tasks: Task Priorities and Cancellation

Imagine running a complex operation, like a large file download, but you want to interrupt it when the user moves away from the relevant screen. Previously, we might have struggled with complex cancellation code.

In Swift 5.5, tasks are first-class citizens. They can be prioritized, and more importantly, cancelled:

In the example, the `async` method returns a `Task.Handle` object, allowing us to cancel the task whenever needed.


With the introduction of Swift concurrency in Swift 5.5, we can bid farewell to callback hells, guard our shared state efficiently with actors, and have better control over tasks. The new concurrency model is a testament to Swift’s evolution towards safer, more efficient, and simpler coding paradigms. As Swift developers, let’s dive in, experiment, and adapt to this exciting new era of concurrent programming.