Cancellation handling in Swift - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Swift async cancellation check?

Consider this Swift async function that checks for cancellation inside a loop. What will be printed when the task is cancelled during execution?

Swift

func performTask() async {
    for i in 1...5 {
        try Task.checkCancellation()
        print("Step \(i) completed")
        try await Task.sleep(nanoseconds: 500_000_000) // 0.5 seconds
    }
    print("Task finished")
}

let task = Task {
    await performTask()
}

Task {
    try await Task.sleep(nanoseconds: 1_200_000_000) // 1.2 seconds
    task.cancel()
}

// Wait for task to finish
try await task.value

A

Step 1 completed
Step 2 completed
Task finished

B

Step 1 completed
Step 2 completed
Step 3 completed

C

Step 1 completed
Step 2 completed
Step 3 completed
Task finished

D

Step 1 completed
Step 2 completed

💡 Hint

Cancellation is checked before each step and the task is cancelled after 1.2 seconds.

The task runs steps with 0.5 seconds delay each. After 1.2 seconds, cancellation is requested. The cancellation check stops the loop after step 2 completes, so only steps 1 and 2 print. The task does not reach step 3 or finish message.

🧠 Conceptual

intermediate

What happens when a Swift Task is cancelled but cancellation is not checked?

In Swift concurrency, if a Task is cancelled but the code inside does not check for cancellation, what is the behavior?

A The Task continues running until it finishes or checks for cancellation explicitly.

B The Task immediately stops execution and throws a cancellation error.

C The Task restarts automatically from the beginning.

D The Task pauses and waits for manual resume.

💡 Hint

Cancellation requires explicit checks in Swift concurrency.

In Swift, cancelling a Task sets its cancellation flag, but the Task code must check for cancellation using Task.checkCancellation() or similar. Without checks, the Task runs normally.

🔧 Debug

advanced

Why does this Swift async function not stop when cancelled?

Given this Swift async function, why does it not stop when the Task is cancelled? func fetchData() async { for i in 1...3 { print("Fetching chunk \(i)") try? await Task.sleep(nanoseconds: 1_000_000_000) } print("Fetch complete") } let task = Task { await fetchData() } Task { try? await Task.sleep(nanoseconds: 1_500_000_000) task.cancel() } try? await task.value

A Because Task.sleep ignores cancellation requests.

B Because the function does not call Task.checkCancellation() to detect cancellation.

C Because the Task.cancel() call is ignored in async functions.

D Because the loop range is fixed and cannot be interrupted.

💡 Hint

Cancellation requires explicit checks in Swift async code.

The function never checks for cancellation explicitly. Task.sleep can throw if cancelled, but try? ignores errors, so cancellation is not detected and the loop continues.

📝 Syntax

advanced

Which option correctly cancels a Swift Task and handles cancellation error?

Which code snippet correctly cancels a Swift Task and handles the cancellation error properly?

Swift

func longRunningTask() async throws {
    for i in 1...5 {
        try Task.checkCancellation()
        print("Processing \(i)")
        try await Task.sleep(nanoseconds: 500_000_000)
    }
}

let task = Task {
    try await longRunningTask()
}

Task {
    try await Task.sleep(nanoseconds: 1_200_000_000)
    task.cancel()
    do {
        try await task.value
    } catch {
        print("Task was cancelled")
    }
}

A Use try await task.value inside do-catch to catch cancellation error and print message.

B Use task.cancel() and ignore task.value completely.

C Use task.cancel() and then immediately call task.value without await or try.

D Use try? await task.value without catch block to ignore cancellation error.

💡 Hint

Cancellation throws an error that must be caught.

Cancellation throws a CancellationError. Using try await task.value inside a do-catch block allows catching this error and handling it gracefully.

🚀 Application

expert

How many times will the print statement execute before cancellation stops the task?

Analyze this Swift async function that checks cancellation and sleeps. How many times will "Working..." print before the task is cancelled? func work() async throws { var count = 0 while true { try Task.checkCancellation() print("Working... \(count)") count += 1 try await Task.sleep(nanoseconds: 300_000_000) // 0.3 seconds } } let task = Task { try await work() } Task { try await Task.sleep(nanoseconds: 1_000_000_000) // 1 second task.cancel() } try? await task.value

A 5 times

B 3 times

C 4 times

D 6 times

💡 Hint

Each loop iteration takes about 0.3 seconds, cancellation happens after 1 second.

Each iteration prints then sleeps 0.3 seconds. After 1 second, cancellation is requested. The task completes 3 full iterations and starts the 4th before cancellation is detected, so 4 prints occur.

Practice

1. What is the main purpose of cancellation handling in Swift concurrency?

easy

A. To create new tasks continuously

B. To speed up all running tasks

C. To restart tasks automatically

D. To stop tasks that are no longer needed

Solution

1. Step 1: Understand cancellation handling concept

   Cancellation handling is used to stop tasks that are no longer needed to save resources.

2. Step 2: Compare options with concept

   Only To stop tasks that are no longer needed matches the purpose of stopping unnecessary tasks.

3. Final Answer:

   To stop tasks that are no longer needed -> Option D

4. Quick Check:

   Cancellation handling = stop unnecessary tasks [OK]

Hint: Cancellation means stopping tasks early to save resources [OK]

Common Mistakes:

• Thinking cancellation speeds up tasks
• Confusing cancellation with restarting tasks
• Assuming cancellation creates new tasks

2. Which of the following is the correct way to check for cancellation inside a Swift async task?

easy

A. if Task.cancelled() { return }

B. if Task.isCancelled { return }

C. if Task.checkCancel() { return }

D. if Task.isCancel { return }

Solution

1. Step 1: Recall correct API for cancellation check

   The correct property to check cancellation is Task.isCancelled.

2. Step 2: Verify syntax correctness

   if Task.isCancelled { return } uses Task.isCancelled correctly; others use invalid method or property names.

3. Final Answer:

   if Task.isCancelled { return } -> Option B

4. Quick Check:

   Use Task.isCancelled to check cancellation [OK]

Hint: Remember: Task.isCancelled is a property, not a method [OK]

Common Mistakes:

• Using incorrect method names like cancelled()
• Confusing property names with similar words
• Missing capitalization or spelling errors

3. What will be the output of the following Swift code snippet?

Task {
    for i in 1...3 {
        try Task.checkCancellation()
        print("Running step \(i)")
        if i == 2 {
            Task.current.cancel()
        }
    }
}

medium

A. Running step 1
Running step 2

B. Running step 1
Running step 2
Running step 3

C. Running step 1

D. No output due to immediate cancellation

Solution

1. Step 1: Understand Task.checkCancellation() behavior

   Task.checkCancellation() throws if the task is cancelled, stopping further execution.

2. Step 2: Analyze loop and cancellation timing

   Cancellation happens when i == 2, so steps 1 and 2 print, but step 3 is skipped due to cancellation.

3. Final Answer:

   Running step 1\nRunning step 2 -> Option A

4. Quick Check:

   Cancellation after step 2 stops step 3 [OK]

Hint: Cancellation stops loop after current iteration [OK]

Common Mistakes:

• Assuming all steps run despite cancellation
• Ignoring that checkCancellation throws on cancel
• Thinking cancellation happens before step 2

4. Identify the error in this Swift async task cancellation handling code:

Task {
    if Task.isCancelled {
        print("Cancelled")
    }
    try Task.checkCancellation()
    print("Running")
}

medium

A. Task.isCancelled check is redundant before checkCancellation()

B. Missing try keyword before Task.checkCancellation()

C. No error; code handles cancellation correctly

D. Task.isCancelled should be checked after checkCancellation()

Solution

1. Step 1: Understand difference between Task.isCancelled and checkCancellation()

   Task.checkCancellation() throws if cancelled, so it already handles cancellation detection.

2. Step 2: Analyze redundancy of Task.isCancelled check

   Checking Task.isCancelled before checkCancellation() is redundant because checkCancellation() will throw if cancelled.

3. Final Answer:

   Task.isCancelled check is redundant before checkCancellation() -> Option A

4. Quick Check:

   checkCancellation() alone suffices to detect cancellation [OK]

Hint: Use checkCancellation() to handle cancellation, no need for isCancelled first [OK]

Common Mistakes:

• Thinking isCancelled must come before checkCancellation()
• Missing try keyword (actually present here)
• Assuming no error when redundancy exists

5. You want to cancel a long-running Swift async task when a user taps a cancel button. Which approach correctly handles cancellation and cleans up resources?

func performTask() async {
    let task = Task {
        do {
            for i in 1...5 {
                try Task.checkCancellation()
                print("Processing \(i)")
                try await Task.sleep(nanoseconds: 1_000_000_000)
            }
        } catch {
            print("Task was cancelled")
        }
        print("Cleanup done")
    }
    // User taps cancel button
    task.cancel()
}

hard

A. Task.cancel() should be called inside the task, not outside

B. Cleanup code will not run after cancellation

C. This code correctly cancels the task and runs cleanup after cancellation

D. Task.checkCancellation() does not throw, so cancellation is ignored

Solution

1. Step 1: Analyze cancellation handling in the task

   Task.checkCancellation() throws when cancelled, caught by catch block which prints cancellation message.

2. Step 2: Verify cleanup code execution

   Cleanup code runs after catch block, ensuring resources are cleaned up even after cancellation.

3. Final Answer:

   This code correctly cancels the task and runs cleanup after cancellation -> Option C

4. Quick Check:

   Cancellation triggers catch and cleanup runs [OK]

Hint: Use try/catch with checkCancellation() to handle cancel and cleanup [OK]

Common Mistakes:

• Assuming cleanup won't run after cancellation
• Calling cancel() inside the task incorrectly
• Believing checkCancellation() does not throw