该死的易懂
Swift 并发

你需要理解的一件事

**隔离**是一切的关键。这是 Swift 对这个问题的答案:现在谁被允许接触这个数据?

为什么不直接用线程?

几十年来,我们通过考虑线程来编写并发代码。问题是什么?**线程不能阻止你搬起石头砸自己的脚。**两个线程可以同时访问相同的数据,导致数据竞争 - 这种 bug 会随机崩溃,几乎无法复现。

在手机上,你可能侥幸过关。但在处理数千个并发请求的服务器上,数据竞争就成了必然 - 通常在生产环境中出现,在周五。随着 Swift 扩展到服务器和其他高度并发的环境,"希望最好的结果"是不够的。

旧的方法是防御性的:使用锁、调度队列,希望你没有漏掉任何地方。

Swift 的方法不同:**在编译时让数据竞争变得不可能。**Swift 不问"这在哪个线程上?",而是问"现在谁被允许接触这个数据?"这就是隔离。

其他语言如何处理这个问题

Swift 和 Rust 是唯一在编译时捕获数据竞争的主流语言。代价是什么?前期学习曲线更陡峭。但一旦你理解了模型,编译器就会支持你。

那些关于 Sendable 和 actor 隔离的烦人错误?它们正在捕获以前会是静默崩溃的 bug。

隔离域

现在你理解了隔离(私人办公室),让我们看看 Swift 办公楼中不同类型的办公室。

MainActor:前台

MainActor 是一个特殊的隔离域,运行在主线程上。这是所有 UI 工作发生的地方。

@MainActor
@Observable
class ViewModel {
    var items: [Item] = []  // UI 状态存在这里

    func refresh() async {
        let newItems = await fetchItems()
        self.items = newItems  // 安全 - 我们在 MainActor 上
    }
}

Actors:部门办公室

actor 就像一个部门办公室 - 它保护自己的数据,一次只允许一个访客。

actor BankAccount {
    var balance: Double = 0

    func deposit(_ amount: Double) {
        balance += amount  // 安全!一次只有一个调用者
    }
}

没有 actor,两个线程读取 balance = 100,都加上 50,都写入 150 - 你损失了 50 美元。有了 actor,Swift 自动排队访问,两次存款都正确完成。

Nonisolated:走廊

标记为 nonisolated 的代码就像走廊 - 它不属于任何办公室,可以从任何地方访问。

actor UserSession {
    let userId: String          // 不可变 - 可以从任何地方安全读取
    var lastActivity: Date      // 可变 - 需要 actor 保护

    nonisolated var displayId: String {
        "User: \(userId)"       // 只读取不可变数据
    }
}

// 用法 - nonisolated 不需要 await
let session = UserSession(userId: "123")
print(session.displayId)  // 同步工作!

对只读取不可变数据的计算属性使用 nonisolated。

隔离如何传播

当你用 actor 隔离标记一个类型时,它的方法会发生什么?闭包呢?理解隔离如何传播是避免意外的关键。

类继承它们的隔离

@MainActor
class ViewModel {
    var count = 0           // MainActor 隔离

    func increment() {      // 也是 MainActor 隔离
        count += 1
    }
}

类内部的所有内容都继承 @MainActor。你不需要标记每个方法。

Task 继承上下文(通常)

@MainActor
class ViewModel {
    func doWork() {
        Task {
            // 这继承了 MainActor!
            self.updateUI()  // 安全,不需要 await
        }
    }
}

从 @MainActor 上下文创建的 Task { } 保持在 MainActor 上。这通常是你想要的。

Task.detached 打破继承

@MainActor
class ViewModel {
    func doWork() {
        Task.detached {
            // 不再在 MainActor 上了!
            await self.updateUI()  // 现在需要 await
        }
    }
}

什么可以跨越边界

现在你知道了隔离域(办公室)以及它们如何传播,下一个问题是:你可以在它们之间传递什么?

Sendable:可以安全共享

这些类型可以安全地跨越隔离边界:

// 带有不可变数据的结构体 - 像复印件
struct User: Sendable {
    let id: Int
    let name: String
}

// Actor 保护自己 - 它们处理自己的访客
actor BankAccount { }  // 自动 Sendable

自动 Sendable:

• 具有 Sendable 属性的值类型(结构体、枚举)
• Actor(它们保护自己)
• 不可变类(final class 只有 let 属性)

Non-Sendable:必须留在原地

这些类型不能安全地跨越边界:

// 带有可变状态的类 - 像原始文档
class Counter {
    var count = 0  // 两个办公室修改这个 = 灾难
}

**为什么这是关键区别?**因为你将遇到的每个编译器错误都归结为:"你试图跨隔离边界发送一个 non-Sendable 类型。"

当编译器抱怨时

如果 Swift 说某些东西不是 Sendable,你有选项:

1. 把它变成值类型 - 使用 struct 而不是 class
2. 隔离它 - 将它保持在 @MainActor 上,这样它就不需要跨越
3. 保持它 non-Sendable - 只是不在办公室之间传递它
4. 最后手段: @unchecked Sendable - 你承诺它是安全的(要小心)

如何跨越边界

你理解了隔离域,你知道什么可以跨越它们。现在:你如何实际在办公室之间通信?

await 关键字

当你在另一个 actor 上调用函数时,你需要 await:

actor DataStore {
    var items: [Item] = []

    func add(_ item: Item) {
        items.append(item)
    }
}

@MainActor
class ViewModel {
    let store = DataStore()

    func addItem(_ item: Item) async {
        await store.add(item)  // 向另一个办公室的请求
        updateUI()             // 回到我们的办公室
    }
}

await 意味着:"发送这个请求并暂停直到它完成。我可能在等待时做其他工作。"

挂起,而非阻塞

关键见解是阻塞和挂起之间的区别:

• 阻塞:你坐在候诊室盯着墙。什么都不会发生。
• 挂起:你留下你的电话号码并去办其他事。他们准备好时会打电话给你。

// 线程闲置,5 秒什么都不做
Thread.sleep(forTimeInterval: 5)

// 线程在等待时被释放去做其他工作
try await Task.sleep(for: .seconds(5))

从同步代码启动异步工作

有时你在同步代码中需要调用异步的东西。使用 Task:

@MainActor
class ViewModel {
    func buttonTapped() {  // 同步函数
        Task {
            await loadData()  // 现在我们可以使用 await
        }
    }
}

有效的模式

网络请求模式

@MainActor
@Observable
class ViewModel {
    var users: [User] = []
    var isLoading = false

    func fetchUsers() async {
        isLoading = true

        // 这会挂起 - 线程可以自由地做其他工作
        let users = await networkService.getUsers()

        // 自动回到 MainActor
        self.users = users
        isLoading = false
    }
}

没有 DispatchQueue.main.async。@MainActor 属性处理它。

用 async let 并行工作

func loadProfile() async -> Profile {
    async let avatar = loadImage("avatar.jpg")
    async let banner = loadImage("banner.jpg")
    async let details = loadUserDetails()

    // 三个全部并行运行!
    return Profile(
        avatar: await avatar,
        banner: await banner,
        details: await details
    )
}

防止双击

这个模式来自 Matt Massicotte 关于有状态系统的指南:

@MainActor
class ButtonViewModel {
    private var isLoading = false

    func buttonTapped() {
        // 在任何异步工作之前同步守卫
        guard !isLoading else { return }
        isLoading = true

        Task {
            await doExpensiveWork()
            isLoading = false
        }
    }
}

要避免的常见错误

这些是常见错误,即使是有经验的开发者也会犯:

认为 async = 后台

// 这仍然阻塞主线程!
@MainActor
func slowFunction() async {
    let result = expensiveCalculation()  // 同步 = 阻塞
    data = result
}

如果你需要在另一个办公室完成工作,明确地把它发送到那里:

func slowFunction() async {
    let result = await Task.detached {
        expensiveCalculation()  // 现在在不同的办公室
    }.value
    await MainActor.run { data = result }
}

创建太多 actor

// 过度设计 - 每次调用都需要在办公室之间走动
actor NetworkManager { }
actor CacheManager { }
actor DataManager { }

// 更好 - 大多数东西可以在前台存在
@MainActor
class AppState { }

到处使用 MainActor.run

// 不要这样做 - 不断走到前台
await MainActor.run { doMainActorStuff() }

// 这样做 - 就在前台工作
@MainActor func doMainActorStuff() { }

让所有东西都 Sendable

不是所有东西都需要是 Sendable。如果你到处添加 @unchecked Sendable,你正在复印不需要离开办公室的东西。

忽略编译器警告

每个关于 Sendable 的编译器警告都是保安告诉你某些东西在办公室之间携带不安全。不要忽略它们 - 理解它们。

常见编译器错误

这些是你会看到的实际错误消息。每一个都是编译器保护你免受数据竞争。

"Sending 'self.foo' risks causing data races"

修复 1: 使用 struct 而不是 class

修复 2: 将它保留在一个 actor 上:

@MainActor
class MyClass {
    var foo: SomeType  // 保留在前台
}

"Non-sendable type cannot cross actor boundary"

修复 1: 把它变成结构体:

// 之前: class (non-Sendable)
class User { var name: String }

// 之后: struct (Sendable)
struct User: Sendable { let name: String }

修复 2: 将它隔离到一个 actor:

@MainActor
class User { var name: String }

"Actor-isolated property cannot be referenced"

修复: 使用 await:

// 错误 - 直接伸手
let value = myActor.balance

// 正确 - 适当的请求
let value = await myActor.balance

"Call to main actor-isolated method in synchronous context"

修复 1: 让调用者成为 @MainActor:

@MainActor
func doSomething() {
    updateUI()  // 相同的隔离,不需要 await
}

修复 2: 使用 await:

func doSomething() async {
    await updateUI()
}

Swift 并发的三个级别

你不需要一次学习所有东西。通过这些级别逐步进步:

这些级别不是严格的界限 - 你的应用的不同部分可能需要不同的级别。一个主要是一级的应用可能有一个需要二级模式的功能。这没问题。对每个部分使用最简单的有效方法。

一级:创业公司

每个人都在前台工作。简单、直接、没有官僚作风。

• 对网络调用使用 async/await
• 用 @MainActor 标记 UI 类
• 使用 SwiftUI 的 .task 修饰符

这处理了 80% 的应用。像 Things、Bear、Flighty 或 Day One 这样的应用可能属于这个类别 - 主要获取数据并显示它的应用。

二级:成长中的公司

你需要同时处理多件事。是时候进行并行项目和协调团队了。

• 对并行工作使用 async let
• 对动态并行使用 TaskGroup
• 理解任务取消

像 Ivory/Ice Cubes(Mastodon 客户端管理多个时间线和流式更新)、Overcast(协调下载、播放和后台同步)或 Slack(跨多个频道的实时消息)这样的应用可能对某些功能使用这些模式。

三级:企业

拥有自己政策的专门部门。复杂的办公室间通信。

• 为共享状态创建自定义 actor
• 深入理解 Sendable
• 自定义执行器

像 Xcode、Final Cut Pro 或服务器端 Swift 框架如 Vapor 和 Hummingbird 这样的应用可能需要这些模式 - 复杂的共享状态、数千个并发连接,或其他人构建的框架级代码。

术语表:你会遇到的更多关键字

除了核心概念,这里是你会在实践中看到的其他 Swift 并发关键字:

何时使用每个

nonisolated - 读取计算属性

默认情况下,actor 内部的所有东西都是隔离的 - 你需要 await 来访问它。但有时你有本质上安全读取的属性:不可变的 let 常量,或只从其他安全数据派生值的计算属性。标记这些为 nonisolated 让调用者同步访问它们,避免不必要的异步开销。

actor UserSession {
    let userId: String  // 不可变,安全读取
    var lastActivity: Date  // 可变,需要保护

    // 这可以在没有 await 的情况下调用
    nonisolated var displayId: String {
        "User: \(userId)"  // 只读取不可变数据
    }
}

// 用法
let session = UserSession(userId: "123")
print(session.displayId)  // 不需要 await!

@Sendable - 跨边界的闭包

当闭包逃逸以便稍后运行或在不同的隔离域上运行时,Swift 需要保证它不会导致数据竞争。@Sendable 属性标记可以安全地跨边界传递的闭包 - 它们不能不安全地捕获可变状态。Swift 经常自动推断这一点(如 Task.detached),但有时在设计接受闭包的 API 时你需要明确声明它。

@MainActor
class ViewModel {
    var items: [Item] = []

    func processInBackground() {
        Task.detached {
            // 这个闭包从分离的任务跨越到 MainActor
            // 它必须是 @Sendable(Swift 推断这个)
            let processed = await self.heavyProcessing()
            await MainActor.run {
                self.items = processed
            }
        }
    }
}

// 需要时的显式 @Sendable
func runLater(_ work: @Sendable @escaping () -> Void) {
    DispatchQueue.global().asyncAfter(deadline: .now() + 1) {
        work()
    }
}

withCheckedContinuation - 桥接旧 API

许多旧 API 使用完成处理程序而不是 async/await。你可以使用 withCheckedContinuation 包装它们,而不是完全重写它们。这个函数挂起当前任务,给你一个 continuation 对象,并在你调用 continuation.resume() 时恢复。"checked" 变体捕获编程错误,如恢复两次或从不恢复。

// 旧的基于回调的 API
func fetchUser(id: String, completion: @escaping (User?) -> Void) {
    // ... 带回调的网络调用
}

// 包装为 async
func fetchUser(id: String) async -> User? {
    await withCheckedContinuation { continuation in
        fetchUser(id: id) { user in
            continuation.resume(returning: user)  // 桥接回来!
        }
    }
}

对于抛出函数,使用 withCheckedThrowingContinuation:

func fetchUserThrowing(id: String) async throws -> User {
    try await withCheckedThrowingContinuation { continuation in
        fetchUser(id: id) { result in
            switch result {
            case .success(let user):
                continuation.resume(returning: user)
            case .failure(let error):
                continuation.resume(throwing: error)
            }
        }
    }
}

AsyncStream - 桥接事件源

虽然 withCheckedContinuation 处理一次性回调,许多 API 随时间传递多个值 - 委托方法、NotificationCenter 或自定义事件系统。AsyncStream 将这些桥接到 Swift 的 AsyncSequence,让你使用 for await 循环。你创建一个流,存储它的 continuation,并在每次新值到达时调用 yield()。

class LocationTracker: NSObject, CLLocationManagerDelegate {
    private var continuation: AsyncStream<CLLocation>.Continuation?

    var locations: AsyncStream<CLLocation> {
        AsyncStream { continuation in
            self.continuation = continuation
        }
    }

    func locationManager(_ manager: CLLocationManager,
                        didUpdateLocations locations: [CLLocation]) {
        for location in locations {
            continuation?.yield(location)
        }
    }
}

// 用法
let tracker = LocationTracker()
for await location in tracker.locations {
    print("新位置: \(location)")
}

Task.isCancelled - 协作取消

Swift 使用协作取消 - 当任务被取消时,它不会立即停止。相反,设置一个标志,你有责任定期检查它。这让你可以控制清理和部分结果。使用 Task.checkCancellation() 立即抛出,或在你想优雅地处理取消时检查 Task.isCancelled(如返回部分结果)。

func processLargeDataset(_ items: [Item]) async throws -> [Result] {
    var results: [Result] = []

    for item in items {
        // 在每个昂贵的操作之前检查
        try Task.checkCancellation()  // 如果被取消则抛出

        // 或者不抛出地检查
        if Task.isCancelled {
            return results  // 返回部分结果
        }

        let result = await process(item)
        results.append(result)
    }

    return results
}

Task.detached - 逃离当前上下文

常规的 Task { } 继承当前的 actor 上下文 - 如果你在 @MainActor 上,任务在 @MainActor 上运行。有时这不是你想要的,特别是对于会阻塞 UI 的 CPU 密集型工作。Task.detached 创建一个没有继承上下文的任务,在后台执行器上运行。谨慎使用 - 大多数时候,具有适当 await 点的常规 Task 就足够了,也更容易推理。

@MainActor
class ImageProcessor {
    func processImage(_ image: UIImage) {
        // 不要:这仍然继承 MainActor 上下文
        Task {
            let filtered = applyFilters(image)  // 阻塞主线程!
        }

        // 要:分离的任务独立运行
        Task.detached(priority: .userInitiated) {
            let filtered = await self.applyFilters(image)
            await MainActor.run {
                self.displayImage(filtered)
            }
        }
    }
}

@preconcurrency - 与遗留代码共存

抑制导入尚未更新并发的模块时的警告:

// 抑制此导入的警告
@preconcurrency import OldFramework

// 或在协议遵从上
class MyDelegate: @preconcurrency SomeOldDelegate {
    // 不会警告 non-Sendable 要求
}

进一步阅读

本指南提炼了关于 Swift 并发的最佳资源。