Advanced Concurrency: async let, TaskGroup & Actors

Reviewed & published by Brayan K

Go beyond a single await. Run work in parallel with async let and withTaskGroup, protect shared state with actors, pin UI work to @MainActor, and let the compiler guard you with Sendable.

Part of the free Swift course at LearnCodingFast — hands-on lessons with worked examples and the output they print, plus practice exercises and a quick quiz.

What You'll Learn in This Lesson

• • Run independent work concurrently with async let
• • Spawn a dynamic number of tasks using withTaskGroup
• • Prevent data races with actors and actor isolation
• • Keep UI work on the main thread with @MainActor
• • Understand Sendable and safe sharing across tasks
• • Appreciate structured concurrency and scoped task lifetimes

📊 Concurrency Tools

1️⃣ async let — Parallel Work

Each async let launches a child task right away. The tasks run side by side; you join the results with await only when you actually use them.

// async let starts work in PARALLEL. Each child task begins immediately;
// you await the results only when you need them.
func fetchUser() async -> String { "Ada" }
func fetchScore() async -> Int { 99 }

func loadProfile() async {
    async let name = fetchUser()    // starts now
    async let score = fetchScore()  // starts now, alongside name

    // Both ran concurrently; await collects their results.
    let result = await "\(name) scored \(score)"
    print(result)   // Ada scored 99
}

Your turn. Fill in the concurrency keywords.

// 🎯 YOUR TURN — replace each ___ then run it in SwiftFiddle.
func loadA() async -> Int { 10 }
func loadB() async -> Int { 20 }

func total() async {
    ___ a = loadA()        // 👉 keyword that starts a parallel child task
    ___ b = loadB()        // 👉 same keyword again
    let sum = ___ a + b    // 👉 keyword that waits for both results
    print("sum = \(sum)")
}

// ✅ Expected output:
//    sum = 30

2️⃣ withTaskGroup — Many Tasks

When the number of tasks isn't fixed, a task group lets you addTask in a loop and gather results with for await as each finishes.

// withTaskGroup runs a DYNAMIC number of child tasks concurrently.
func square(_ n: Int) async -> Int { n * n }

func squareAll(_ numbers: [Int]) async -> [Int] {
    await withTaskGroup(of: Int.self) { group in
        for n in numbers {
            group.addTask { await square(n) }   // each runs concurrently
        }
        var results: [Int] = []
        for await value in group {              // collect as they finish
            results.append(value)
        }
        return results.sorted()
    }
}

// await squareAll([1, 2, 3, 4]) -> [1, 4, 9, 16]

3️⃣ Actors — Safe Shared State

An actor serializes access to its state so only one task touches it at a time — no data races. Code inside the actor is synchronous; code outside must await. Use @MainActor to pin UI work to the main thread, and Sendable to mark types safe to share.

// An actor protects its mutable state: only one task touches it at a time,
// so there are no data races. Cross-actor access is async (needs await).
actor Counter {
    private var value = 0

    func increment() { value += 1 }   // inside the actor: synchronous
    func current() -> Int { value }
}

func run() async {
    let counter = Counter()
    await counter.increment()         // outside the actor: needs await
    await counter.increment()
    let now = await counter.current()
    print("count = \(now)")          // count = 2
}

Now you try. Add the keyword cross-actor calls need.

// 🎯 YOUR TURN — make the access compile.
actor Bank {
    private var balance = 0
    func deposit(_ amount: Int) { balance += amount }
    func total() -> Int { balance }
}

func demo() async {
    let bank = Bank()
    ___ bank.deposit(100)        // 👉 keyword needed for cross-actor calls
    let t = ___ bank.total()     // 👉 same keyword to read the result
    print("balance = \(t)")
}

// ✅ Expected output:
//    balance = 100

Pro Tips

• 💡 Only parallelise independent work. If B needs A's result, a plain sequential await is correct.
• 💡 Mark view models @MainActor so every state change is main-thread safe.
• 💡 Prefer actors over locks. They give race-free state with no manual mutex code.
• 💡 Let the compiler help. Sendable warnings flag unsafe sharing before it bites at runtime.

Common Errors (and the fix)

• "Expression is 'async' but is not marked with 'await'" — cross-actor access needs await.
• No parallelism observed — you awaited each async let immediately; await only when you need the value.
• "Main actor-isolated property can not be referenced" — hop onto the main actor with @MainActor or await MainActor.run.
• Sendable warning — you passed a non-Sendable reference type into a task; make it immutable or an actor.

📋 Quick Reference

Mini-Challenge: Parallel Sizes

Fetch two simulated sizes in parallel and sum them, then try the task-group version. Compare with the comments.

// 🎯 MINI-CHALLENGE: Parallel image sizes (simulated)
// 1. Write an async func sizeOf(_ name: String) async -> Int that returns
//    name.count (pretend it's a download).
// 2. Use async let to fetch sizeOf("cat") and sizeOf("elephant") in parallel.
// 3. await both and print their sum.
// 4. Bonus: rewrite it with withTaskGroup over an array of names.
//
// ✅ Example output (cat=3, elephant=8):
//    total = 11

// your code here

🎉 Lesson Complete!

• ✅ async let runs a fixed set of tasks in parallel
• ✅ withTaskGroup handles a dynamic number of tasks
• ✅ Actors serialize state access and stop data races
• ✅ @MainActor keeps UI work on the main thread
• ✅ Sendable marks types safe to cross concurrency boundaries

Practice quiz

Continue this course

• Previous: Combine Operators & Pipelines
• Next: Networking with URLSession & async/await — Fetch and decode JSON with URLSession.data(from:) and Codable

Frequently asked questions

How is async let different from a plain await?

A plain await runs work sequentially: the line blocks until the result arrives before the next line starts. async let starts a child task immediately and lets execution continue, so several pieces of work run in parallel. You then await the binding only when you actually need its value, which is where the results join back together.

When should I use a TaskGroup instead of async let?

Use async let for a small, fixed set of concurrent tasks known at compile time. Use withTaskGroup (or withThrowingTaskGroup) when the number of child tasks is dynamic, for example one per element of an array. The group lets you add tasks in a loop and collect their results with for await as they complete.

What exactly does an actor protect against?

An actor serializes access to its mutable state so only one task can touch that state at a time. This eliminates data races, the bugs that arise when multiple threads read and write shared mutable data simultaneously. Code inside the actor accesses its state synchronously; code outside must use await because cross-actor access is asynchronous.

What is @MainActor for?

@MainActor is a global actor that isolates code to the main thread. Annotate a type, function, or property with it to guarantee that code runs on the main thread, which is required for UI updates in SwiftUI and UIKit. Many SwiftUI view-model patterns mark the whole ObservableObject as @MainActor so all UI-facing state changes are main-thread safe.

What does Sendable mean?

Sendable is a protocol marking types that can be safely passed across concurrency boundaries, such as into another task or actor, without causing data races. Value types made of Sendable parts are usually Sendable automatically. Reference types need care: they must be immutable or internally synchronized. The compiler uses Sendable to catch unsafe sharing at compile time.