Task for launching concurrent work in Swift - Mini Project: Build & Apply

Task for launching concurrent work

📖 Scenario: You are building a simple Swift program that runs two tasks at the same time to save time. This is like asking two friends to do two jobs together instead of waiting for one to finish before starting the other.

🎯 Goal: Learn how to use Task in Swift to launch concurrent work and print results when both tasks finish.

📋 What You'll Learn

Create two separate tasks using Task

Each task should print a message after a short delay

Use await to wait for both tasks to finish

Print a final message after both tasks complete

💡 Why This Matters

🌍 Real World

Running multiple tasks at the same time helps apps stay fast and responsive, like loading images while fetching data.

💼 Career

Understanding concurrency with Swift's Task API is important for building efficient iOS and macOS apps that handle multiple operations smoothly.

1

Create two async functions

Write two async functions called taskOne() and taskTwo(). Each function should wait for 1 second using Task.sleep and then print "Task One done" or "Task Two done" respectively.

Swift

# Write async functions taskOne() and taskTwo() with 1 second delay and print statements

Hint

Use try? await Task.sleep(nanoseconds: 1_000_000_000) to wait 1 second inside each async function.

2

Launch tasks concurrently

Create two variables task1 and task2 using Task to run taskOne() and taskTwo() concurrently.

Swift

import Foundation

func taskOne() async {
    try? await Task.sleep(nanoseconds: 1_000_000_000)
    print("Task One done")
}

func taskTwo() async {
    try? await Task.sleep(nanoseconds: 1_000_000_000)
    print("Task Two done")
}

// Create Task variables task1 and task2 to run taskOne() and taskTwo()

Hint

Use let task1 = Task { await taskOne() } and similarly for task2.

3

Wait for both tasks to finish

Use await on task1.value and task2.value to wait for both tasks to complete.

Swift

import Foundation

func taskOne() async {
    try? await Task.sleep(nanoseconds: 1_000_000_000)
    print("Task One done")
}

func taskTwo() async {
    try? await Task.sleep(nanoseconds: 1_000_000_000)
    print("Task Two done")
}

let task1 = Task {
    await taskOne()
}

let task2 = Task {
    await taskTwo()
}

// Await task1.value and task2.value to wait for completion

Hint

Use await task1.value and await task2.value inside a Task to wait for both.

4

Print final message after tasks complete

After awaiting both tasks, print "Both tasks completed" inside the same Task.

Swift

import Foundation

func taskOne() async {
    try? await Task.sleep(nanoseconds: 1_000_000_000)
    print("Task One done")
}

func taskTwo() async {
    try? await Task.sleep(nanoseconds: 1_000_000_000)
    print("Task Two done")
}

let task1 = Task {
    await taskOne()
}

let task2 = Task {
    await taskTwo()
}

Task {
    await task1.value
    await task2.value
    // Print final message here
}

Hint

After waiting for both tasks, add print("Both tasks completed").

Practice

1.

What does Task { } do in Swift concurrency?

easy

A. Creates a synchronous function

B. Starts a new piece of work that runs concurrently with other code

C. Blocks the main thread until the work finishes

D. Stops all other tasks from running

Solution

1. Step 1: Understand the purpose of Task

   Task { } is used to start work that runs at the same time as other code, without blocking.

2. Step 2: Compare options

   Only Starts a new piece of work that runs concurrently with other code correctly describes this concurrent behavior. Options A, B, and D are incorrect because they describe blocking, synchronous, or stopping behavior, which Task does not do.

3. Final Answer:

   Starts a new piece of work that runs concurrently with other code -> Option B

4. Quick Check:

   Task starts concurrent work = C [OK]

Hint: Task runs code concurrently without blocking [OK]

Common Mistakes:

• Thinking Task blocks the main thread
• Confusing Task with synchronous functions
• Believing Task stops other tasks

2.

Which of the following is the correct syntax to start a new concurrent task in Swift?

?

easy

A. task { fetchData() }

B. async Task { fetchData() }

C. Task.start { fetchData() }

D. Task { await fetchData() }

Solution

1. Step 1: Recall correct Task syntax

   The correct way to start a concurrent task is Task { } with a closure inside. Using await is needed if calling async functions.

2. Step 2: Check each option

   Task { await fetchData() } uses correct capitalization and syntax. Options A, C, and D use incorrect keywords or syntax.

3. Final Answer:

   Task { await fetchData() } -> Option D

4. Quick Check:

   Correct Task syntax = B [OK]

Hint: Task must be capitalized and use braces { } [OK]

Common Mistakes:

• Using lowercase 'task' instead of 'Task'
• Adding 'start' method which doesn't exist
• Adding 'async' keyword before Task incorrectly

3.

What will be printed by this Swift code?

Task {
    print("Start")
    await Task.sleep(1_000_000_000) // 1 second
    print("End")
}
print("Outside")

medium

A. Start\nOutside\nEnd

B. Outside\nStart\nEnd

C. Outside\nEnd\nStart

D. Start\nEnd\nOutside

Solution

1. Step 1: Understand Task concurrency

   The Task { } runs concurrently, so "Start" prints immediately when the task begins.

2. Step 2: Trace print order

   Within the Task, "Start" prints first, then the task sleeps for 1 second, then prints "End". Meanwhile, the main thread continues and prints "Outside" immediately after starting the Task.

3. Step 3: Determine exact order

   Because the Task closure starts immediately and prints "Start" before sleeping, "Start" prints before "Outside". Then "Outside" prints, and after 1 second delay, "End" prints.

4. Final Answer:

   Start\nOutside\nEnd -> Option A

5. Quick Check:

   Task prints Start immediately, main prints Outside, then Task prints End = D [OK]

Hint: Task closure starts immediately and prints Start before main thread prints Outside [OK]

Common Mistakes:

• Assuming 'Outside' prints before 'Start'
• Ignoring that Task closure starts immediately
• Thinking Task blocks main thread

4.

Identify the error in this Swift code that tries to launch a concurrent task:

Task {
    let result = fetchData()
    print(result)
}

Assuming fetchData() is an async function.

medium

A. Missing await before fetchData()

B. Task cannot be used with async functions

C. print cannot be called inside Task

D. fetchData() must be synchronous

Solution

1. Step 1: Check async function call

   Since fetchData() is async, it must be called with await inside an async context like Task.

2. Step 2: Identify missing await

   The code misses await before fetchData(), causing a compile error.

3. Final Answer:

   Missing await before fetchData() -> Option A

4. Quick Check:

   Async calls need await = A [OK]

Hint: Async calls inside Task need await keyword [OK]

Common Mistakes:

• Forgetting await on async calls
• Thinking Task disallows async calls
• Believing print can't be used inside Task

5.

You want to fetch user data and update the UI without blocking the main thread. Which is the best way to launch this concurrent work?

func updateUI(with data: String) {
    print("UI updated with \(data)")
}

func fetchUserData() async -> String {
    // Simulate network delay
    await Task.sleep(2_000_000_000)
    return "User123"
}

// What code should you write here?

hard

A. Task {
let data = fetchUserData()
updateUI(with: data)
}

B. let data = fetchUserData()
updateUI(with: data)

C. Task {
let data = await fetchUserData()
updateUI(with: data)
}

D. updateUI(with: fetchUserData())

Solution

1. Step 1: Understand async fetch and UI update

   Fetching user data is async and takes time. To avoid blocking, use Task { } to run it concurrently.

2. Step 2: Use await and update UI inside Task

   Inside the Task, await the async fetch, then update the UI with the result. This keeps UI responsive.

3. Final Answer:

   Task { let data = await fetchUserData() updateUI(with: data) } -> Option C

4. Quick Check:

   Await async fetch inside Task, then update UI = A [OK]

Hint: Await async calls inside Task before UI update [OK]

Common Mistakes:

• Calling async function without await
• Updating UI outside Task causing blocking
• Not using Task for concurrency