Why modern concurrency matters in Swift

Introduction

Modern concurrency helps your app do many things at once without freezing or slowing down. It makes programs faster and smoother, just like a busy kitchen where many cooks work together without bumping into each other.

When your app needs to download pictures while still letting the user tap buttons.

When you want to load data from the internet and show it without waiting for everything to finish.

When you have tasks that take time, like reading files or processing information, and you don't want the app to stop working.

When you want to run multiple tasks at the same time to save waiting time.

When you want your app to feel quick and responsive even if it's doing a lot behind the scenes.

Syntax

Swift

func fetchData() async throws -> Data {
    // Your code to fetch data
}

Task {
    do {
        let data = try await fetchData()
        print("Data received")
    } catch {
        print("Error fetching data")
    }
}

async marks a function that can pause and wait for work without blocking the app.

await tells the program to wait for a task to finish before moving on.

Examples

This example shows a simple async function that loads an image and waits for it inside a Task.

Swift

func loadImage() async -> UIImage {
    // pretend to load image
    return UIImage()
}

Task {
    let image = await loadImage()
    print("Image loaded")
}

This example uses Task.sleep to pause without freezing the app.

Swift

Task {
    print("Start")
    try? await Task.sleep(nanoseconds: 2_000_000_000) // wait 2 seconds
    print("End")
}

Sample Program

This program shows how to fetch a number asynchronously with a delay. It prints messages before and after waiting, so you see the app stays responsive.

Swift

import Foundation
import UIKit

func fetchNumber() async -> Int {
    // Simulate a delay
    try? await Task.sleep(nanoseconds: 1_000_000_000) // 1 second
    return 42
}

Task {
    print("Fetching number...")
    let number = await fetchNumber()
    print("Number received: \(number)")
}

// Keep the program running to see output
RunLoop.main.run(until: Date().addingTimeInterval(2))

Important Notes

Modern concurrency uses async and await to make code easier to read and write.

Using concurrency correctly prevents your app from freezing or feeling slow.

Always test your async code to make sure it handles errors and delays well.

Summary

Modern concurrency lets your app do many things at once smoothly.

Use async and await to write clear, non-blocking code.

This helps apps stay fast and responsive, improving user experience.

Practice

1. What is the main benefit of using modern concurrency with async and await in Swift?

easy

A. It makes your app use more memory.

B. It allows your app to do many tasks at the same time without freezing.

C. It slows down your app to avoid errors.

D. It removes the need for functions.

Solution

1. Step 1: Understand what concurrency means

   Concurrency means doing multiple tasks at once, which helps apps stay responsive.

2. Step 2: Connect concurrency with async and await

   These keywords let Swift run tasks without waiting and freezing the app.

3. Final Answer:

   It allows your app to do many tasks at the same time without freezing. -> Option B

4. Quick Check:

   Modern concurrency = smooth multitasking [OK]

Hint: Remember: async/await = multitasking without freezing [OK]

Common Mistakes:

• Thinking concurrency slows the app down
• Confusing concurrency with more memory use
• Believing async/await removes functions

2. Which of the following is the correct way to declare an asynchronous function in Swift?

easy

A. func fetchData() async -> String

B. async func fetchData() -> String

C. func async fetchData() -> String

D. func fetchData() -> async String

Solution

1. Step 1: Recall Swift async function syntax

   In Swift, async comes after the function parentheses.

2. Step 2: Check each option's syntax

   Only func fetchData() async -> String places async correctly after the parentheses.

3. Final Answer:

   func fetchData() async -> String -> Option A

4. Quick Check:

   async keyword after () = correct syntax [OK]

Hint: Put async right after () in function declaration [OK]

Common Mistakes:

• Placing async before func
• Inserting async inside parameter list
• Putting async before return type

3. What will be printed by this Swift code using async/await?

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

Task {
    let number = await fetchNumber()
    print(number)
}

medium

A. Nothing prints

B. await fetchNumber()

C. Error: missing await

D. 10

Solution

1. Step 1: Understand async function behavior

   The function fetchNumber() returns 10 asynchronously.

2. Step 2: Check how Task and await work

   The Task runs the async code, and await waits for the result before printing.

3. Final Answer:

   10 -> Option D

4. Quick Check:

   await fetchNumber() returns 10 [OK]

Hint: await waits for async result before printing [OK]

Common Mistakes:

• Forgetting to use await
• Expecting print before result is ready
• Thinking async functions run instantly

4. Identify the error in this Swift async code:

func loadData() async -> String {
    return "Data"
}

func printData() {
    let result = await loadData()
    print(result)
}

medium

A. loadData should not be async

B. await cannot be used inside printData

C. Missing async keyword in printData function declaration

D. printData should return String

Solution

1. Step 1: Check where await is used

   The function printData() uses await inside its body.

2. Step 2: Confirm async requirement for await

   Any function using await must be marked async.

3. Final Answer:

   Missing async keyword in printData function declaration -> Option C

4. Quick Check:

   await requires async function [OK]

Hint: Add async to any function using await [OK]

Common Mistakes:

• Not marking function async when using await
• Thinking await can be used in normal functions
• Confusing async with return type

5. You want to fetch user data and user posts concurrently in Swift using async/await. Which approach best uses modern concurrency to improve speed?

hard

A. Use async let to start both fetchUser() and fetchPosts() at the same time, then await both results.

B. Run fetchUser() synchronously, then fetchPosts() asynchronously.

C. Call fetchUser() and fetchPosts() one after another with await each time.

D. Use DispatchQueue without async/await to run both tasks.

Solution

1. Step 1: Understand sequential vs concurrent calls

   Calling await one after another waits for the first to finish before starting the second.

2. Step 2: Use async let for concurrency

   Using async let starts both tasks simultaneously, improving speed.

3. Final Answer:

   Use async let to start both fetchUser() and fetchPosts() at the same time, then await both results. -> Option A

4. Quick Check:

   async let = concurrent tasks [OK]

Hint: Use async let to run tasks together, then await results [OK]

Common Mistakes:

• Awaiting tasks one by one causing delay
• Mixing synchronous and asynchronous calls incorrectly
• Using old concurrency methods instead of async/await