Structured Concurrency in Swift

|

Structured concurrency is one of the most significant advancements introduced in Swift to simplify asynchronous programming. Prior to its introduction, developers relied heavily on callback-based APIs, completion handlers, and Grand Central Dispatch (GCD), which often led to complex, hard-to-maintain, and error-prone code. Structured concurrency brings a more organized and readable approach to managing asynchronous tasks by enforcing a hierarchy and lifecycle for concurrent operations.

At its core, structured concurrency ensures that tasks are created within a well-defined scope and that their lifetimes are tied to that scope. This approach not only improves readability but also enhances safety, as it prevents issues such as orphaned tasks, memory leaks, and unpredictable execution flows.

This article explores structured concurrency in Swift with a focus on parent-child relationships, automatic cancellation, and task groups. Along the way, we will examine practical coding examples that demonstrate how these concepts work together to create robust and efficient asynchronous code.

Understanding Structured Concurrency

Structured concurrency is built on the idea that tasks should not exist independently without a clear owner. Instead, every task is part of a hierarchy where a parent task manages one or more child tasks. This relationship ensures that all child tasks complete before the parent task finishes.

In Swift, structured concurrency is primarily implemented using the async/await syntax and the Task API. This model allows developers to write asynchronous code that looks and behaves similarly to synchronous code, making it easier to reason about.

Here is a simple example:

func fetchData() async -> String {
    return "Data received"
}

func process() async {
    let result = await fetchData()
    print(result)
}

In this example, the process() function awaits the result of fetchData(). The execution is suspended until the data is available, without blocking the thread.

Parent-Child Relationships in Tasks

One of the defining characteristics of structured concurrency is the parent-child relationship between tasks. When a task creates another task using structured APIs like async let or TaskGroup, the created task becomes a child of the parent task.

This relationship introduces several guarantees:

  • The parent task cannot complete until all its child tasks have completed.
  • Errors thrown by child tasks can propagate to the parent.
  • Cancellation signals propagate downward from parent to children.

Let’s look at an example using async let:

func downloadImage() async -> String {
    return "Image"
}

func downloadMetadata() async -> String {
    return "Metadata"
}

func loadResources() async {
    async let image = downloadImage()
    async let metadata = downloadMetadata()
    
    let results = await (image, metadata)
    print(results)
}

In this code:

  • downloadImage() and downloadMetadata() run concurrently.
  • Both are child tasks of loadResources().
  • The parent task (loadResources) waits for both child tasks to complete before proceeding.

This pattern ensures that concurrency remains predictable and controlled.

Benefits of Parent-Child Task Hierarchies

The hierarchical model of tasks offers several benefits:

  1. Deterministic Execution: Tasks are guaranteed to complete within a defined scope.
  2. Improved Error Handling: Errors can propagate naturally through the task hierarchy.
  3. Simplified Resource Management: Resources tied to tasks are automatically cleaned up when tasks complete.

For example, consider error propagation:

enum NetworkError: Error {
    case failed
}

func fetchUser() async throws -> String {
    throw NetworkError.failed
}

func loadUserData() async {
    do {
        let user = try await fetchUser()
        print(user)
    } catch {
        print("Error: \(error)")
    }
}

If a child task throws an error, the parent task can catch and handle it appropriately, maintaining a clean and predictable flow.

Automatic Cancellation in Structured Concurrency

Automatic cancellation is another powerful feature of structured concurrency. When a parent task is cancelled, all its child tasks are automatically cancelled as well. This ensures that no unnecessary work continues after it is no longer needed.

Cancellation in Swift is cooperative, meaning tasks must periodically check whether they have been cancelled and respond accordingly.

Here is an example:

func longRunningTask() async {
    for i in 1...10 {
        if Task.isCancelled {
            print("Task cancelled")
            return
        }
        print("Processing \(i)")
        try? await Task.sleep(nanoseconds: 1_000_000_000)
    }
}

func performWork() {
    let task = Task {
        await longRunningTask()
    }
    
    task.cancel()
}

In this example:

  • The task checks Task.isCancelled during execution.
  • When task.cancel() is called, the task stops gracefully.

Cancellation Propagation in Parent-Child Tasks

Let’s see how cancellation propagates through parent-child relationships:

func childTask() async {
    while !Task.isCancelled {
        print("Child working...")
        try? await Task.sleep(nanoseconds: 500_000_000)
    }
    print("Child cancelled")
}

func parentTask() {
    let task = Task {
        await childTask()
    }
    
    DispatchQueue.global().asyncAfter(deadline: .now() + 2) {
        task.cancel()
    }
}

Here, when the parent task is cancelled, the child task automatically receives the cancellation signal and terminates.

This propagation mechanism is essential for building responsive applications, especially when dealing with user-initiated cancellations such as navigating away from a screen.

Task Groups for Dynamic Concurrency

While async let is useful for a fixed number of tasks, Swift provides TaskGroup for managing a dynamic number of concurrent tasks. Task groups allow you to spawn multiple child tasks and collect their results as they complete.

Here is a basic example:

func fetchNumber(_ number: Int) async -> Int {
    return number * 2
}

func processNumbers() async {
    await withTaskGroup(of: Int.self) { group in
        for i in 1...5 {
            group.addTask {
                await fetchNumber(i)
            }
        }
        
        for await result in group {
            print("Result: \(result)")
        }
    }
}

In this example:

  • A task group is created using withTaskGroup.
  • Five child tasks are added dynamically.
  • Results are processed as they become available.

Error Handling in Task Groups

Task groups also support error handling through withThrowingTaskGroup. This allows tasks to throw errors that can be handled at the group level.

func riskyTask(_ value: Int) async throws -> Int {
    if value == 3 {
        throw NSError(domain: "Error", code: 1)
    }
    return value
}

func runTasks() async {
    do {
        try await withThrowingTaskGroup(of: Int.self) { group in
            for i in 1...5 {
                group.addTask {
                    try await riskyTask(i)
                }
            }
            
            for try await result in group {
                print("Processed: \(result)")
            }
        }
    } catch {
        print("Error occurred: \(error)")
    }
}

If any task throws an error:

  • The group cancels all remaining tasks.
  • The error propagates to the caller.

Task Group Cancellation Behavior

Task groups automatically handle cancellation in a structured way. If one task fails or if the group is cancelled, all remaining tasks are cancelled.

func cancellableTask(_ id: Int) async {
    while !Task.isCancelled {
        print("Task \(id) running")
        try? await Task.sleep(nanoseconds: 500_000_000)
    }
    print("Task \(id) cancelled")
}

func runCancellableGroup() async {
    await withTaskGroup(of: Void.self) { group in
        for i in 1...3 {
            group.addTask {
                await cancellableTask(i)
            }
        }
        
        try? await Task.sleep(nanoseconds: 2_000_000_000)
        group.cancelAll()
    }
}

This demonstrates how task groups provide a unified mechanism for managing cancellation across multiple concurrent tasks.

Comparing async let and Task Groups

While both async let and TaskGroup enable concurrency, they serve different purposes:

  • async let
    • Best for a fixed number of tasks
    • Simpler syntax
    • Implicit structure
  • TaskGroup
    • Ideal for dynamic or large sets of tasks
    • More flexible
    • Supports advanced patterns like early exits and incremental result processing

Choosing between them depends on the use case and complexity of the task.

Best Practices for Structured Concurrency

To fully leverage structured concurrency in Swift, consider the following best practices:

  1. Use async/await whenever possible to simplify asynchronous code.
  2. Prefer structured APIs like async let and TaskGroup over unstructured Task.
  3. Handle cancellation explicitly by checking Task.isCancelled.
  4. Keep tasks small and focused to improve readability and maintainability.
  5. Use task groups for scalability when dealing with variable workloads.

Conclusion

Structured concurrency in Swift represents a fundamental shift in how asynchronous programming is approached. By introducing a clear and enforceable hierarchy of tasks, it eliminates many of the pitfalls associated with traditional concurrency models, such as callback hell, race conditions, and unmanaged task lifecycles.

The concept of parent-child relationships is central to this model. It ensures that every task has a well-defined owner and lifecycle, creating a predictable execution environment. This structure not only improves code readability but also enforces discipline in how concurrency is handled, making large-scale applications easier to reason about and maintain.

Automatic cancellation further enhances this model by ensuring that unnecessary work does not continue once it is no longer needed. The ability for cancellation signals to propagate through the task hierarchy is particularly valuable in real-world applications, where user interactions often dictate the need to stop ongoing processes. This leads to more responsive and efficient applications, conserving both computational resources and energy.

Task groups extend the power of structured concurrency by enabling dynamic concurrency patterns. They provide a flexible yet controlled way to manage multiple concurrent tasks, handle errors gracefully, and process results incrementally. This makes them an indispensable tool for scenarios involving parallel data processing, network requests, or any situation where the number of tasks is not fixed in advance.

Together, these features create a cohesive and powerful concurrency model that balances flexibility with safety. Developers can write asynchronous code that is not only efficient but also intuitive and maintainable. The combination of async/await, parent-child task hierarchies, automatic cancellation, and task groups ensures that Swift remains at the forefront of modern programming paradigms.

Ultimately, structured concurrency is not just a new feature—it is a new way of thinking about concurrency. By embracing its principles, developers can build applications that are more robust, scalable, and easier to understand, paving the way for more reliable and high-performance software systems.