Structured concurrency in iOS Swift

Introduction

Structured concurrency helps you write clear and safe asynchronous code. It keeps tasks organized so they finish properly and errors are handled well.

When you want to run multiple tasks at the same time and wait for all to finish.

When you need to cancel a group of related tasks together.

When you want to avoid messy code with callbacks or manual thread management.

When you want your app to stay responsive while doing background work.

When you want to handle errors from multiple tasks in one place.

Syntax

iOS Swift

func example() async {
  await withTaskGroup(of: Void.self) { group in
    group.addTask {
      // async work here
    }
    // more tasks can be added
  }
}

withTaskGroup creates a group of tasks that run concurrently.

All tasks inside the group must finish before the group ends.

Examples

This example runs two tasks that return numbers and sums their results.

iOS Swift

await withTaskGroup(of: Int.self) { group in
  group.addTask { 1 }
  group.addTask { 2 }
  var sum = 0
  for await value in group {
    sum += value
  }
  print(sum) // prints 3
}

This example shows how to handle errors in tasks using a throwing task group.

iOS Swift

await withThrowingTaskGroup(of: String.self) { group in
  group.addTask { try await fetchData() }
  for try await result in group {
    print(result)
  }
}

Sample App

This SwiftUI app has a button that starts two tasks concurrently. Each task waits some time and then returns a message. The messages show in a list when tasks finish.

iOS Swift

import SwiftUI

struct ContentView: View {
  @State private var results = [String]()

  var body: some View {
    VStack {
      Button("Start Tasks") {
        Task {
          await runTasks()
        }
      }
      List(results, id: \.self) { item in
        Text(item)
      }
    }
    .padding()
  }

  func runTasks() async {
    await withTaskGroup(of: String.self) { group in
      group.addTask {
        try await Task.sleep(nanoseconds: 1_000_000_000)
        return "Task 1 done"
      }
      group.addTask {
        try await Task.sleep(nanoseconds: 500_000_000)
        return "Task 2 done"
      }
      for await result in group {
        await MainActor.run {
          results.append(result)
        }
      }
    }
  }
}

Important Notes

Structured concurrency helps avoid bugs by making sure all tasks finish or cancel together.

Use withTaskGroup for simple tasks and withThrowingTaskGroup when tasks can throw errors.

Remember to update UI on the main thread if needed, but SwiftUI's @State handles this automatically inside async tasks.

Summary

Structured concurrency organizes async tasks into groups that run and finish together.

It makes async code easier to read, write, and maintain.

Use task groups to run multiple tasks concurrently and collect their results safely.

Practice

1. What is the main purpose of structured concurrency in Swift's async code?

easy

A. To make synchronous code run faster

B. To organize async tasks into groups that run and finish together

C. To avoid using async/await keywords

D. To write code without any error handling

Solution

1. Step 1: Understand structured concurrency concept

   Structured concurrency groups async tasks so they start and finish as a unit.

2. Step 2: Compare options with concept

   Only To organize async tasks into groups that run and finish together correctly describes this grouping and coordination of async tasks.

3. Final Answer:

   To organize async tasks into groups that run and finish together -> Option B

4. Quick Check:

   Structured concurrency = task grouping [OK]

Hint: Structured concurrency means grouping async tasks [OK]

Common Mistakes:

• Thinking it speeds up synchronous code
• Confusing it with removing async/await
• Ignoring error handling in async tasks

2. Which of the following is the correct syntax to create a task group in Swift concurrency?

easy

A. await withTaskGroup(of: Int.self) { group in ... }

B. withTaskGroup await (of: Int.self) { group in ... }

C. taskGroup await (Int) { group in ... }

D. await taskGroup(of: Int) { group in ... }

Solution

1. Step 1: Recall correct syntax for task groups

   The correct syntax uses 'await withTaskGroup(of: Type.self) { group in ... }'.

2. Step 2: Check each option's syntax

   Only await withTaskGroup(of: Int.self) { group in ... } matches the correct Swift syntax for task groups.

3. Final Answer:

   await withTaskGroup(of: Int.self) { group in ... } -> Option A

4. Quick Check:

   Correct task group syntax = await withTaskGroup(of: Int.self) { group in ... } [OK]

Hint: Remember 'await withTaskGroup(of: Type.self)' syntax [OK]

Common Mistakes:

• Placing 'await' after 'withTaskGroup'
• Using wrong order of keywords
• Omitting '.self' after type

3. What will be the output of this Swift code snippet using a task group?

func fetchValues() async -> [Int] {
  await withTaskGroup(of: Int.self) { group in
    group.addTask { 10 }
    group.addTask { 20 }
    var results = [Int]()
    for await value in group {
      results.append(value)
    }
    return results.sorted()
  }
}

Task {
  let values = await fetchValues()
  print(values)
}

medium

A. Compilation error

B. [20, 10]

C. [10]

D. [10, 20]

Solution

1. Step 1: Understand task group execution

   Two tasks return 10 and 20 concurrently; results are collected in 'results'.

2. Step 2: Analyze result sorting and output

   Results are sorted before returning, so output is [10, 20].

3. Final Answer:

   [10, 20] -> Option D

4. Quick Check:

   Task group collects and sorts results [OK]

Hint: Task group results can arrive unordered; sorting fixes order [OK]

Common Mistakes:

• Assuming order of results matches task add order
• Forgetting to sort results
• Expecting compilation error due to async

4. Identify the error in this Swift code using structured concurrency:

func loadData() async {
  await withTaskGroup(of: String.self) { group in
    group.addTask { "First" }
    group.addTask { "Second" }
    for value in group {
      print(value)
    }
  }
}

medium

A. Incorrect type specified in withTaskGroup

B. group.addTask syntax is invalid

C. Missing 'await' before 'for' loop to iterate group

D. No error, code is correct

Solution

1. Step 1: Check iteration over task group

   Iterating over a task group requires 'for await' to await each task's result.

2. Step 2: Identify missing 'await' keyword

   The code uses 'for value in group' instead of 'for await value in group', causing error.

3. Final Answer:

   Missing 'await' before 'for' loop to iterate group -> Option C

4. Quick Check:

   Use 'for await' to iterate async task groups [OK]

Hint: Use 'for await' to loop over async task groups [OK]

Common Mistakes:

• Using 'for' instead of 'for await' on task groups
• Confusing task group type with task return type
• Misusing addTask syntax

5. You want to fetch data from multiple URLs concurrently and combine their results safely. Which approach best uses structured concurrency in Swift?

hard

A. Use 'await withTaskGroup' to add a task for each URL fetch, then collect and combine results

B. Create multiple detached tasks without waiting, then combine results later

C. Fetch URLs one by one synchronously in a loop

D. Use DispatchQueue.global().async without task groups

Solution

1. Step 1: Understand structured concurrency for multiple async tasks

   Using 'await withTaskGroup' allows running multiple async tasks concurrently and safely collecting results.

2. Step 2: Compare approaches for concurrency and safety

   Use 'await withTaskGroup' to add a task for each URL fetch, then collect and combine results uses task groups correctly; others either run tasks unsafely or synchronously.

3. Final Answer:

   Use 'await withTaskGroup' to add a task for each URL fetch, then collect and combine results -> Option A

4. Quick Check:

   Task groups = safe concurrent task management [OK]

Hint: Use task groups to run and gather multiple async tasks safely [OK]

Common Mistakes:

• Using detached tasks without waiting causes race conditions
• Fetching synchronously loses concurrency benefits
• Using DispatchQueue without structured concurrency loses safety