Structured concurrency model in Swift - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of async let with structured concurrency

What is the output of this Swift code using structured concurrency with async let?

Swift

func fetchNumber() async -> Int {
    return 10
}

func fetchDouble() async -> Int {
    return 20
}

func test() async {
    async let a = fetchNumber()
    async let b = fetchDouble()
    let sum = await a + await b
    print(sum)
}

Task {
    await test()
}

A 30

B 10

C 20

D Compilation error

💡 Hint

Remember that async let runs tasks concurrently and you must await their results.

The async let bindings run fetchNumber() and fetchDouble() concurrently. Awaiting both and adding results gives 10 + 20 = 30.

🧠 Conceptual

intermediate

Understanding Task Groups in Swift concurrency

Which statement best describes the behavior of TaskGroup in Swift's structured concurrency?

A TaskGroup runs child tasks sequentially and returns after the first completes.

B TaskGroup runs child tasks concurrently but does not wait for any to finish.

C TaskGroup runs child tasks concurrently and waits for all to complete before continuing.

D TaskGroup runs child tasks sequentially and returns immediately.

💡 Hint

Think about how structured concurrency manages child tasks and their lifetimes.

TaskGroup runs multiple child tasks concurrently and suspends the parent until all child tasks complete, ensuring structured concurrency.

🔧 Debug

advanced

Identify the runtime error in this structured concurrency code

What runtime error will this Swift code produce when executed?

Swift

func test() async {
    async let a = Task.sleep(nanoseconds: 1_000_000_000) // 1 second
    print("Before await")
    let _ = await a
    print("After await")
}

Task {
    await test()
}

A Runtime error: Task cancellation error

B No error, prints 'Before await' then 'After await' after 1 second

C Compilation error due to incorrect Task.sleep usage

D Deadlock error because async let cannot be awaited

💡 Hint

Check how Task.sleep is used and awaited in async let.

Task.sleep suspends the current task for the specified nanoseconds. async let runs it concurrently. Awaiting it after printing 'Before await' works fine.

❓ Predict Output

advanced

Output of nested TaskGroup with cancellation

What will be printed by this Swift code using nested TaskGroups and cancellation?

Swift

func test() async {
    await withTaskGroup(of: Void.self) { group in
        group.addTask {
            print("Task 1 start")
            try? await Task.sleep(nanoseconds: 500_000_000)
            print("Task 1 end")
        }
        group.addTask {
            print("Task 2 start")
            Task.current.cancel()
            try? await Task.sleep(nanoseconds: 1_000_000_000)
            print("Task 2 end")
        }
    }
}

Task {
    await test()
}

A No output due to immediate cancellation

B

Task 1 start
Task 2 start
Task 2 end
Task 1 end

C

Task 2 start
Task 1 start
Task 2 end

D

Task 1 start
Task 2 start
Task 1 end

💡 Hint

Consider how cancellation affects running tasks and which prints happen before cancellation.

Task 2 cancels the current task but the sleep is cancellable. Task 2's sleep is skipped, so 'Task 2 end' is not printed. Task 1 runs normally.

🧠 Conceptual

expert

Effect of structured concurrency on resource cleanup

Which best describes how Swift's structured concurrency model helps with resource cleanup in asynchronous code?

A It automatically cancels child tasks when the parent task finishes or throws an error, ensuring cleanup.

B It requires manual cancellation of all child tasks to free resources.

C It delays resource cleanup until the entire program exits.

D It does not affect resource cleanup; developers must manage it explicitly.

💡 Hint

Think about how structured concurrency scopes child tasks to their parent.

Structured concurrency scopes child tasks to their parent task. When the parent finishes or errors, child tasks are cancelled automatically, helping resource cleanup.