Swift Concurrency: actors and Sendable

Reentrancy: actors aren’t transactions

An actor runs one piece of its code at a time, but every await inside an actor method is a suspension point where other calls can run. State you read before an await may be different after it:

actor Counter {
    private(set) var value = 0

    func incrementSlowly() async {
        let current = value
        try? await Task.sleep(for: .milliseconds(100))
        value = current + 1
    }
}

let counter = Counter()
async let first: Void = counter.incrementSlowly()
async let second: Void = counter.incrementSlowly()
_ = await (first, second)
print(await counter.value)

The same shape appears as duplicate work: an image cache checks images[url], misses, awaits a download, and a second request for the same URL does the same in the meantime. The fix (the exercise below) is to store the in-flight task before suspending.

Sendable in practice

• Value types whose stored properties are all Sendable are implicitly Sendable (for non-public types). This is why value-type models cross actors for free.
• Classes are Sendable only if final with immutable (let) Sendable properties, or isolated to a global actor (@MainActor classes are Sendable, because all access goes through the main actor).
• sending and region isolation let you pass a non-Sendable value to another domain when the compiler can prove the sender never touches it again, which removes many false positives from Swift 5.10.
• @unchecked Sendable is a promise the compiler can’t verify: valid only with internal synchronization (a Mutex from the Synchronization module on iOS 18+, or OSAllocatedUnfairLock), and worth a comment explaining why.
• nonisolated(unsafe) for globals is the same kind of promise; prefer making the global a let of a Sendable type.

A token store that silences the compiler

final class TokenStore: @unchecked Sendable {
    private var token: String?

    func update(_ newToken: String) { token = newToken }
    func current() -> String? { token }
}

// Used from the API client (many concurrent requests) and the refresh task:
let tokens = TokenStore()

import Synchronization

final class TokenStore: Sendable {                 // checked: Mutex is Sendable
    private let token = Mutex<String?>(nil)

    func update(_ newToken: String) { token.withLock { $0 = newToken } }
    func current() -> String? { token.withLock { $0 } }
}

Deep dives

Choosing isolation

• UI and view models: @MainActor. In Swift 6.2, app targets can make that the default (-default-isolation MainActor, the “Default Actor Isolation” build setting in new Xcode projects), so code is main-actor unless you opt out. It removes most annotations from UI code and makes the opt-outs (nonisolated, @concurrent) visible.
• Shared mutable state used from many tasks: an actor, or a Mutex for tiny critical sections that never await (actors cost a suspension per call).
• CPU-heavy pure functions: nonisolated (and @concurrent in Swift 6.2 when called from an actor, so they don’t run on the caller’s executor), taking and returning Sendable values.
• Task {} vs Task.detached {}: Task {} inherits the current actor, priority and task-locals; detached inherits nothing. Both are unstructured: nothing waits for them or cancels them automatically, so store the handle when the work must be cancelled, and prefer async let, task groups, .task and async closures.
• Cancellation is cooperative: it sets a flag. Long loops must check Task.isCancelled or call try Task.checkCancellation(); system APIs like URLSession and Task.sleep check for you.

actor ImageLoader {
    private enum Entry {
        case inProgress(Task<Data, Error>)
        case ready(Data)
    }

    private var entries: [URL: Entry] = [:]
    private let session: URLSession

    init(session: URLSession = .shared) { self.session = session }

    func image(for url: URL) async throws -> Data {
        if let entry = entries[url] {
            switch entry {
            case .ready(let data):
                return data
            case .inProgress(let task):
                return try await task.value            // join the download already running
            }
        }

        let task = Task {                              // not structured: shared by every caller
            let (data, response) = try await session.data(from: url)
            guard (response as? HTTPURLResponse)?.statusCode == 200 else { throw URLError(.badServerResponse) }
            return data
        }
        entries[url] = .inProgress(task)               // stored BEFORE the first await

        do {
            let data = try await task.value
            entries[url] = .ready(data)
            return data
        } catch {
            entries[url] = nil                         // allow a retry later
            throw error
        }
    }
}