Pocket Budget is about to call a server for exchange rates. A request might take 200 milliseconds or eight seconds on a train. If the main thread, which draws the UI and handles touches, sat waiting for it, the app would freeze and iOS might eventually kill it. Swift’s concurrency model lets you write code that waits without blocking, in a style that reads top to bottom, and Swift 6 adds a compiler that proves your concurrent code has no data races.
\nimport Foundation\n\nstruct RateService {\n func fetchRate(from base: String, to target: String) async throws -> Decimal {\n try await Task.sleep(for: .milliseconds(300)) // stands in for a network call\n return target == \"EUR\" ? 0.92 : 0.79\n }\n}async in the signature means “this function can pause”. Every call to it is marked await, which marks a suspension point: the function may pause there, the thread goes off to do other work (like scrolling a list), and the function resumes when the result is ready. async combines with throws, so the call is try await. In the next lesson the Task.sleep becomes a real request.
Async functions can only be called from an async context. SwiftUI gives you one with the .task modifier:
@MainActor\n@Observable\nfinal class BudgetStore {\n var expenses: [Expense] = []\n var euroRate: Decimal?\n var isLoadingRate = false\n private let rates = RateService()\n\n func loadEuroRate() async {\n isLoadingRate = true\n defer { isLoadingRate = false }\n do {\n euroRate = try await rates.fetchRate(from: \"USD\", to: \"EUR\")\n } catch {\n euroRate = nil\n }\n }\n}\n\nstruct RateBanner: View {\n let store: BudgetStore\n\n var body: some View {\n Group {\n if store.isLoadingRate {\n ProgressView()\n } else if let rate = store.euroRate {\n Text(\"1 USD = \\(rate.formatted()) EUR\")\n } else {\n Text(\"Rate unavailable\")\n }\n }\n .task {\n await store.loadEuroRate()\n }\n }\n}.task starts when the view appears and is cancelled automatically when it disappears, so a user who leaves the screen doesn’t leave a request running in the background. For a button tap, wrap the call in Task { await store.loadEuroRate() }, which starts new top-level work. defer resets the loading flag however the function exits.
Two independent requests shouldn’t wait for each other. async let starts work immediately and lets you collect it later:
func loadBothRates(using service: RateService) async throws -> (eur: Decimal, gbp: Decimal) {\n async let eur = service.fetchRate(from: \"USD\", to: \"EUR\")\n async let gbp = service.fetchRate(from: \"USD\", to: \"GBP\")\n return try await (eur, gbp)\n}Both requests run at the same time, so this takes about 300 ms instead of 600. For a number of tasks you only know at runtime, use a task group:
\nfunc loadRates(for codes: [String], using service: RateService) async throws -> [String: Decimal] {\n try await withThrowingTaskGroup(of: (String, Decimal).self) { group in\n for code in codes {\n group.addTask {\n (code, try await service.fetchRate(from: \"USD\", to: code))\n }\n }\n var rates: [String: Decimal] = [:]\n for try await (code, rate) in group {\n rates[code] = rate\n }\n return rates\n }\n}This is structured concurrency: child tasks live inside their parent’s scope. The function can’t return while a child is still running, if one child throws the others are cancelled, and cancelling the parent cancels every child. Notice that each child returns its result and the parent assembles the dictionary. Children never write to shared state.
\nA data race happens when two threads access the same memory at the same time and at least one writes. The result is corrupted data or a crash that appears once in a thousand runs. Swift 6 language mode turns the checks for this into compile errors, organised around isolation: every piece of mutable state belongs to exactly one domain, and only code in that domain may touch it directly.
\nThree tools cover almost every case in an app:
\nThe main actor. @MainActor isolates a type to the main thread. UI state belongs there, which is why BudgetStore is marked @MainActor above: the views that read it run on the main actor, and now the compiler guarantees nothing else writes to it. New app projects in Xcode 26 and later set the Default Actor Isolation build setting to MainActor, so your app code is main-actor isolated unless you say otherwise. It’s a sensible default: most app code is UI code.
Actors. An actor is a reference type that protects its own state by running one call at a time. Code outside the actor must await to reach it:
actor RateCache {\n private var rates: [String: Decimal] = [:]\n\n func rate(for code: String) -> Decimal? {\n rates[code]\n }\n\n func save(_ rate: Decimal, for code: String) {\n rates[code] = rate\n }\n}\n\n// From anywhere: await cache.save(0.92, for: \"EUR\")Sendable values. A type is Sendable when it’s safe to pass between domains. Value types made of Sendable parts (String, Decimal, your Expense struct) qualify automatically, as do actors and main-actor-isolated classes. A plain class with var properties doesn’t, and the compiler stops you from sharing one between tasks.
That’s the vocabulary: async, await, tasks, actors, Sendable. You don’t need to master every rule at once; read each compiler error as a question about which domain owns the data. Next you replace the pretend Task.sleep with a real request and decode the JSON it returns.
await marks a point where a function may pause; the thread is free to do other work, such as keeping the UI responsive, while it waits.","Start async work from a view with .task, which SwiftUI cancels automatically when the view disappears.","async let and task groups run work in parallel as child tasks that must finish, or be cancelled, before their parent returns.","Swift 6 refuses to compile code where two tasks could touch the same mutable state at once; actors and Sendable types are how you satisfy it.","Keep UI state on the main actor with @MainActor; new Xcode projects make main-actor isolation the default for app code."],"further":[{"title":"Concurrency (The Swift Programming Language)","url":"https://docs.swift.org/swift-book/documentation/the-swift-programming-language/concurrency/"},{"title":"Swift 6 Migration Guide","url":"https://www.swift.org/migration/documentation/migrationguide/"},{"title":"Updating an app to use strict concurrency","url":"https://developer.apple.com/documentation/swift/updating-an-app-to-use-strict-concurrency"}],"quiz":[{"q":"A view loads exchange rates in .task { await store.loadEuroRate() }. The user leaves the screen before the request finishes. What happens?
Task { } inside a button would do. .task is tied to the view’s lifetime."},{"text":"SwiftUI cancels the task, and cancellation-aware calls like Task.sleep or URLSession requests throw.","why":"Correct. Cancellation is cooperative; well-behaved async APIs notice it and stop early."},{"text":"The app crashes because the view no longer exists.","why":"The task holds what it needs; it doesn’t depend on the view struct staying around."}],"answer":1},{"q":"async let eur = fetch("EUR") and async let gbp = fetch("GBP"), each taking about 300 ms, followed by try await (eur, gbp). Roughly how long does it take?
async let starts a child task immediately; the await collects both results."},{"text":"About 600 ms, because each await waits in turn.","why":"That’s two plain try await calls in sequence. async let starts both before either is awaited."},{"text":"Instantly, because async let doesn’t wait.","why":"The work still takes time; async let only lets it overlap."}],"answer":0},{"q":"Why can you call await cache.save(rate, for: "EUR") on an actor from many tasks at once without a data race?
await.","why":"Correct. That serialization is why every outside call to an actor needs await."}],"answer":2},{"q":"Which type is Sendable without you writing anything extra?
final class with a var property.","why":"Mutable shared state is exactly what Sendable rules out; the compiler won’t infer it."},{"text":"A non-public struct whose stored properties are all Sendable, such as String and Decimal.","why":"Correct. Value types made of Sendable values can be copied safely across tasks, so Swift infers it."},{"text":"Any class marked @Observable.","why":"Observable classes are mutable and not Sendable unless they’re isolated to an actor such as @MainActor."}],"answer":1}],"exercise":{"kind":"spot-bug","language":"swift","code":"import Foundation\n\nfinal class Tally {\n var total: Decimal = 0\n}\n\nfunc totalOfAll(_ amounts: [Decimal]) async -> Decimal {\n let tally = Tally()\n await withTaskGroup(of: Void.self) { group in\n for amount in amounts {\n group.addTask { tally.total += amount }\n }\n }\n return tally.total\n}","bugLines":[11],"title":"The data race Swift 6 refuses to build","prompt":"This helper totals a list of amounts using a task group. It would run fine in a quick test, yet the Swift 6 compiler refuses to build it. Select the line that creates the data race.
\n","hints":["How many child tasks are running at the same time, and what are they all touching?","Tally is an ordinary class with a var. Is it Sendable?","In structured concurrency, children should hand results back to the parent rather than writing to shared state."],"explanation":"Line 11 starts one child task per amount, and every child mutates the same Tally object. Child tasks run in parallel, so two of them can read and write total at the same moment and lose an update. Because Tally isn’t Sendable, Swift 6 rejects the capture (“passing closure as a ‘sending’ parameter risks causing data races”, or a main-actor isolation error when your project uses main-actor default isolation).
Let each child return its value and sum in the parent, which only ever runs one loop iteration at a time:
\nfunc totalOfAll(_ amounts: [Decimal]) async -> Decimal {\n await withTaskGroup(of: Decimal.self) { group in\n for amount in amounts {\n group.addTask { amount }\n }\n var total: Decimal = 0\n for await part in group {\n total += part\n }\n return total\n }\n}If the state really must be shared, make Tally an actor and call await tally.add(amount).