Task and TaskGroup in iOS Swift - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ ui_behavior

intermediate

Understanding TaskGroup concurrency behavior

Consider this Swift code using TaskGroup. What will be printed first?

iOS Swift

func testTaskGroup() async {
  await withTaskGroup(of: String.self) { group in
    group.addTask { "First" }
    group.addTask { "Second" }
    for await result in group {
      print(result)
      break
    }
  }
  print("Done")
}

Task {
  await testTaskGroup()
}

A Done\nSecond

B Second\nDone

C Done\nFirst

D First\nDone

💡 Hint

The first completed task result is printed before breaking the loop.

The for await loop prints the first completed task's result, which is "First" here, then breaks. After the group ends, "Done" is printed.

❓ lifecycle

intermediate

Task cancellation inside TaskGroup

What happens if a task inside a TaskGroup calls Task.cancel() on itself?

iOS Swift

func cancelInsideGroup() async {
  await withTaskGroup(of: Void.self) { group in
    group.addTask {
      Task.cancel()
      print("Cancelled")
    }
    group.addTask {
      print("Running")
    }
  }
}

Task {
  await cancelInsideGroup()
}

A Prints "Cancelled" and "Running"

B Prints only "Running"

C Prints only "Cancelled"

D No output, tasks are cancelled immediately

💡 Hint

Cancellation does not stop the current task immediately.

Calling Task.cancel() marks the task as cancelled but does not stop execution immediately, so "Cancelled" is printed. The other task runs normally.

📝 Syntax

advanced

Correct syntax for adding tasks in TaskGroup

Which option correctly adds a task returning an Int in a TaskGroup?

iOS Swift

func addTaskExample() async {
  await withTaskGroup(of: Int.self) { group in
    // Add a task here
  }
}

A group.addTask { 42 }

B group.addTask { return 42 }

C group.addTask { await 42 }

D group.addTask { async { 42 } }

💡 Hint

The closure can return the value directly without return keyword.

Option A is correct because the closure returns 42 directly. Option A is valid Swift but redundant here. Option A is invalid because 'await' is not needed for a literal. Option A is invalid syntax.

🔧 Debug

advanced

Why does this TaskGroup code deadlock?

Given this code, why does it deadlock?

iOS Swift

func deadlockExample() async {
  await withTaskGroup(of: Void.self) { group in
    group.addTask {
      await deadlockExample() // recursive call
    }
  }
}

Task {
  await deadlockExample()
}

A Because the task is not awaited properly

B Because the recursive call waits for the group to finish, causing a cycle

C Because TaskGroup does not support recursion

D Because the group is empty and never completes

💡 Hint

Think about waiting inside the group for itself to finish.

The recursive call awaits the same TaskGroup to finish, causing a deadlock cycle where the group waits on itself.

🧠 Conceptual

expert

TaskGroup result ordering guarantee

Which statement about the order of results from withTaskGroup is true?

A Results are returned in the order tasks were added

B Results are returned in random order each run

C Results are returned in the order tasks complete

D Results are returned sorted by their value

💡 Hint

Think about concurrency and task completion timing.

TaskGroup yields results as tasks complete, so order depends on completion, not addition order.

Practice

1. What is the main purpose of a Task in Swift concurrency?

easy

A. To run a single background job asynchronously

B. To group multiple tasks and run them together

C. To update the UI on the main thread

D. To pause the app execution

Solution

1. Step 1: Understand what Task does

   A Task is designed to run one asynchronous job in the background.

2. Step 2: Differentiate from TaskGroup

   TaskGroup runs many jobs together, not a single job.

3. Final Answer:

   To run a single background job asynchronously -> Option A

4. Quick Check:

   Task = single background job [OK]

Hint: Task runs one job; TaskGroup runs many [OK]

Common Mistakes:

• Confusing Task with TaskGroup
• Thinking Task updates UI directly
• Assuming Task pauses app execution

2. Which of the following is the correct syntax to create a Task that prints "Hello" asynchronously?

easy

A. async Task { print("Hello") }

B. TaskGroup { print("Hello") }

C. Task.run { print("Hello") }

D. Task { print("Hello") }

Solution

1. Step 1: Recall correct Task syntax

   The correct way to create a Task is using Task { ... } with a closure.

2. Step 2: Check other options for errors

   TaskGroup is not used like this; async Task and Task.run are invalid syntax.

3. Final Answer:

   Task { print("Hello") } -> Option D

4. Quick Check:

   Correct Task syntax = Task { print("Hello") } [OK]

Hint: Use Task { } with closure for async code [OK]

Common Mistakes:

• Using TaskGroup instead of Task
• Adding 'async' keyword before Task
• Trying to call Task.run which doesn't exist

3. What will be printed by this Swift code using TaskGroup?

func fetchData() async {
  await withTaskGroup(of: String.self) { group in
    group.addTask { "A" }
    group.addTask { "B" }
    for await result in group {
      print(result)
    }
  }
}
fetchData()

medium

A. Either A then B or B then A (order not guaranteed)

B. B then A in order

C. A then B in order

D. No output because of syntax error

Solution

1. Step 1: Understand TaskGroup concurrency

   TaskGroup runs tasks concurrently and collects results as they finish, order is not guaranteed.

2. Step 2: Analyze the code output

   Since tasks return "A" and "B" concurrently, the print order can be either "A" then "B" or "B" then "A".

3. Final Answer:

   Either A then B or B then A (order not guaranteed) -> Option A

4. Quick Check:

   TaskGroup results order is unpredictable [OK]

Hint: TaskGroup runs tasks concurrently; output order varies [OK]

Common Mistakes:

• Assuming TaskGroup results are always ordered
• Thinking tasks run sequentially
• Believing syntax error prevents output

4. Identify the error in this Swift code using TaskGroup:

await withTaskGroup(of: Int.self) { group in
  group.addTask { 1 }
  group.addTask { 2 }
  for result in group {
    print(result)
  }
}

medium

A. Incorrect type in 'withTaskGroup' declaration

B. Using 'for' instead of 'for await' to iterate the group

C. Missing 'await' before 'for' loop

D. Cannot add tasks inside 'withTaskGroup'

Solution

1. Step 1: Check iteration over TaskGroup

   Iteration over a TaskGroup is asynchronous, so it requires for await.

2. Step 2: Identify the error in the code

   The code uses for result in group without await, causing a compile error.

3. Final Answer:

   Using 'for' instead of 'for await' to iterate the group -> Option B

4. Quick Check:

   Async iteration needs 'for await' [OK]

Hint: Use 'for await' to loop over TaskGroup results [OK]

Common Mistakes:

• Forgetting 'await' in asynchronous loops
• Confusing TaskGroup type declaration
• Thinking tasks can't be added inside withTaskGroup

5. You want to fetch user data from three different servers concurrently and combine the results. Which Swift concurrency pattern using TaskGroup is best to achieve this?

hard

A. Create three separate Task instances and wait for each sequentially

B. Run three synchronous functions one after another on the main thread

C. Use a TaskGroup to add three tasks fetching data, then collect all results asynchronously

D. Use a single Task that fetches data from all servers sequentially

Solution

1. Step 1: Understand concurrency needs

   Fetching from three servers concurrently requires running tasks in parallel to save time.

2. Step 2: Choose the best Swift concurrency pattern

   TaskGroup allows adding multiple tasks and collecting results asynchronously, perfect for this use case.

3. Final Answer:

   Use a TaskGroup to add three tasks fetching data, then collect all results asynchronously -> Option C

4. Quick Check:

   TaskGroup = concurrent multiple tasks [OK]

Hint: Use TaskGroup for multiple concurrent tasks and results [OK]

Common Mistakes:

• Running tasks sequentially losing concurrency benefits
• Using synchronous calls blocking main thread
• Using single Task for sequential fetches