Task groups for parallel execution in Swift - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of concurrent task group with async sleeps

What is the output of this Swift code using task groups for parallel execution?

Swift

import Foundation

func testTaskGroup() async {
    await withThrowingTaskGroup(of: String.self) { group in
        group.addTask {
            try await Task.sleep(nanoseconds: 1_000_000_000)
            return "First"
        }
        group.addTask {
            try await Task.sleep(nanoseconds: 500_000_000)
            return "Second"
        }
        group.addTask {
            return "Third"
        }

        for try await result in group {
            print(result)
        }
    }}

Task {
    await testTaskGroup()
}
RunLoop.main.run()

A

Third
First
Second

B

First
Second
Third

C

Second
Third
First

D

Third
Second
First

💡 Hint

Remember that tasks in a task group complete independently and results are received as they finish.

The task that returns "Third" has no delay and finishes first. The task with 0.5s delay finishes second, and the 1s delay task finishes last. The for-await loop prints results as tasks complete.

🧠 Conceptual

intermediate

Understanding task group cancellation behavior

In Swift concurrency, what happens to remaining tasks in a task group if one task throws an error?

A Only the task that threw the error is cancelled; others continue.

B All remaining tasks are immediately cancelled and the error is propagated.

C The task group waits for all tasks to finish before propagating the error.

D Remaining tasks continue running and the error is ignored.

💡 Hint

Think about how Swift handles errors in concurrent task groups to avoid wasted work.

When a task in a task group throws, Swift cancels all remaining tasks immediately and propagates the error to the caller.

🔧 Debug

advanced

Identify the error in this task group code

What error does this Swift code produce?

Swift

import Foundation

func runTasks() async throws {
    await withThrowingTaskGroup(of: Int.self) { group in
        for i in 1...3 {
            group.addTask {
                if i == 2 {
                    throw NSError(domain: "Test", code: 1)
                }
                return i
            }
        }

        for try await value in group {
            print(value)
        }
    }}

Task {
    do {
        try await runTasks()
    } catch {
        print("Error: \(error)")
    }
}
RunLoop.main.run()

A Runtime error: Task group throws and cancels remaining tasks

B Compilation error: 'throw' used in non-throwing closure

C No error; prints 1 and 3

D Deadlock because tasks wait on each other

💡 Hint

Check if the closure passed to addTask supports throwing errors.

The original code causes a compilation error because the closure passed to addTask is non-throwing but contains a 'throw' statement. Changing to withThrowingTaskGroup and marking runTasks as async throws fixes this.

📝 Syntax

advanced

Correct syntax for adding tasks with return values in a task group

Which option shows the correct syntax to add tasks returning Int values in a Swift task group?

Swift

await withTaskGroup(of: Int.self) { group in
    // Add tasks here
}

A group.addTask(async { 5 })

B group.addTask { await 5 }

C group.addTask { return 5 }

D group.addTask { throw 5 }

💡 Hint

Remember the closure passed to addTask can be async but does not require 'await' for returning a value.

Option C correctly adds a task returning 5. Option C misuses 'await' on a literal. Option C uses invalid syntax. Option C tries to throw a non-error value.

🚀 Application

expert

Calculate sum of squares using task groups concurrently

Given this Swift code, what is the value of 'total' after execution?

Swift

import Foundation

func sumOfSquares(_ numbers: [Int]) async -> Int {
    await withTaskGroup(of: Int.self) { group in
        for number in numbers {
            group.addTask {
                number * number
            }
        }

        var sum = 0
        for await value in group {
            sum += value
        }
        return sum
    }
}

Task {
    let total = await sumOfSquares([1, 2, 3, 4])
    print(total)
}
RunLoop.main.run()

A 30

B 20

C 10

D 25

💡 Hint

Calculate each number squared and add them all: 1² + 2² + 3² + 4².

1*1=1, 2*2=4, 3*3=9, 4*4=16; sum is 1+4+9+16=30.