并发编程向协程的进化 In Swift 6

前言

现代编程语言解决了线程爆炸，但也带来了类型爆炸问题

并行：指真正的同时执行，例如 6核心CPU(A19 芯片为例)，最大并行数就是 6，6个任务跑在6个核心上，可以同时执行，所以并行的单词为: parallel (para-前缀有平行的意思)

并发：严格来讲并行属于并发的理想情况。通常所说的并发是指，时间片快速在不同线程之间切换(例如 10us 切换一次)，而带给用户在同时执行的假象。而非正在的并行。并发的英文单词为 concurrency (协同发生)。

1. Task：Task 是 Swift 并发模型的 “最小执行单元”，Task 封装的任务，可以丢到任何空闲线程执行

2. await / async 函数挂起，异步等待点，本质上是依赖 Task 做任务挂起

3. Actor: 状态隔离+Task 调度(Task 如何串行排队)，一个 Actor 内部开启新 Task，Task 内部会脱离当前 Actor 执行域

┌─────────────────────────────────┐
│ Actor（状态隔离+Task 调度）      │ 👈 最高层：封装 Task 实现安全并发
└───────────────────┬─────────────┘
                    │
┌───────────────────▼─────────────┐
│ async/await（Task 异步语法糖）   │ 👈 中间层：简化 Task 的异步编写
└───────────────────┬─────────────┘
                    │
┌───────────────────▼─────────────┐
│ Task（并发最小执行单元）         │ 👈 最底层：所有并发的基础
└─────────────────────────────────┘

1、线程数量 ≈ CPU 核心数

• Swift 并发调度器会尽量维持合适的线程池大小，通常和 CPU 核心数相关。

• 并不是每个 Task 都创建一个线程，而是 Task 在少量线程上调度执行。

2、线程长期运行，挂起的是任务 Task

• Task 内部用 协程（continuation） 挂起和恢复。

• 线程本身不会被阻塞，挂起的是函数执行状态（stack frame 和寄存器上下文）。

• 当 Task 挂起时，线程可以跑别的任务，提高 CPU 利用率。

• 线程上下文成本开销变大 （需要记录线程上下文、开关中断、trap到内核态、内核态到用户态切换）

• CPU 的时间片变短(被过多的线程数量切割)，无法完整执行一个有效任务，任务频繁切换

3、Task 协程与线程不阻塞

一、逐渐淡化的 GCD

二、Task 新的底层并发基石

• 调度代码在全局并发池（或指定 Actor）执行；

• 处理异步暂停 / 恢复（挂起时释放线程，恢复时重新调度）；

• 传递任务的结果 / 错误；

• Task 不依赖 async/await 或 Actor —— 你可以直接创建 Task 执行同步代码（但无意义）；

• 所有 async 函数的执行，最终都必须挂载到某个 Task 上（没有 Task，async 代码无法执行）。

// 最底层：直接创建 Task，无需 async/await
let task = Task {
    print("Task 执行中：\(Thread.current)") // 后台线程
    Thread.sleep(forTimeInterval: 1) // 模拟耗时操作
    return "Task 完成"
}
// 等待 Task 结果（本质是 await，Swift 隐式处理）
Task {
    let result = await task.value
    print(result)
}

三、async / await (Task 挂起/恢复便捷语法)

• async：标记函数 “需要在 Task 中执行，且可能暂停”；

• await：标记 “此处可能暂停当前 Task，等待异步操作完成后恢复”；

追踪任务依赖：

四、Actor 隔离域

机制 1：状态隔离（Actor Isolation）—— 核心中的核心

• 规则：Actor 的所有属性（状态）只能被 Actor 自身的方法访问，外部线程 / 任务必须通过异步调用（await）访问，且同一时间只有一个任务能进入 Actor 的 “执行域”。

• 底层逻辑：Actor 内部维护一个串行执行队列，所有对 Actor 状态的访问 / 修改都排队执行，天然避免多线程同时操作。

• 编译期保障：Swift 编译器会强制检查 —— 如果外部试图直接访问 Actor 属性（而非 await 调用），会直接报错：

actor SafeCounter {
    var count = 0
    func increment() { count += 1 }
}

let safeCounter = SafeCounter()
safeCounter.count // ❌ 编译报错：Actor-isolated instance method 'increment()' cannot be called from outside of the actor
safeCounter.increment() // ❌ 编译报错：同上
Task {
    await safeCounter.increment() // ✅ 必须 await，异步访问
    let c = await safeCounter.count // ✅ 读取也需 await
}

机制 2：重入安全（Reentrancy）—— 避免死锁的关键

• 定义：当 Actor 正在执行一个异步方法（比如 func doAsync() async）且暂停等待（比如 await 其他操作）时，允许其他任务进入 Actor 执行队列，而非阻塞。

• 为什么需要重入？假设 Actor 不支持重入，当一个异步方法 A 执行到 await 时，Actor 会被 “锁住”，如果此时另一个任务调用 Actor 的方法 B，会一直阻塞，直到 A 执行完 —— 这会导致死锁（比如 A 等待 B 的结果，B 等待 A 释放 Actor）。

• 示例：Actor 重入的合理性(await 挂起点后，释放 actor 执行权)

actor ImageLoader {
    var cache: [String: UIImage] = [:]
    // 缓存正在下载的任务，避免重复下载
    var pendingDownloads: [String: Task<UIImage?, Never>] = [:]

    func loadImage(url: String) async -> UIImage? {
        // 1. 先查缓存（Actor 执行域）
        if let img = cache[url] { return img }
        // 2. 检查是否已有下载任务，有则直接等待其结果
        if let existingTask = pendingDownloads[url] {
            return await existingTask.value
        }
        // 3. 无则创建下载任务，加入 pendingDownloads
        let downloadTask = Task {
            await downloadImage(url: url)
        }
        pendingDownloads[url] = downloadTask

        // 4. 等待下载结果
        let img = await downloadTask.value

        // 5. 清理 pendingDownloads + 更新缓存（串行安全）
        pendingDownloads.removeValue(forKey: url)
        if let img = img {
            cache[url] = img
        }
        return img
    }
}

机制 3：调度（Scheduling）—— 隐藏的执行逻辑

• 默认调度器：Actor 使用 GlobalActor（全局并发池）调度任务，优先级继承自调用方；

• 自定义调度器：可通过 @MainActor 标记 Actor，使其所有方法都在主线程执行（UI 相关 Actor 常用）：

@MainActor
actor UIActor {
    var uiState: String = ""
    func updateUI(text: String) { // 自动在主线程执行
        uiState = text
    }
}

• 调度规则：Actor 的任务队列是先入先出（FIFO），但异步暂停的任务会重新排队，保证最终执行的串行性。

Actor 中执行到 await 被挂起的任务，在异步操作完成恢复后，不会直接继续执行，而是重新排到该 Actor 执行队列的队尾，等待前面的任务执行完毕后再串行执行。

五、Task / Await 在 Actor 上的心智模型区别

await 不换 Actor，Task {} 换执行域

“这里是 suspend（await）还是 spawn（Task）？”

@MainActor
func foo() {
    Task {
        // ❌ 这里不保证在 MainActor
    }
}

@MainActor
func foo() async {
    await bar()
    // ✅ 这里仍然在 MainActor
}

• Task {} = 我明确要并发 / 脱离当前执行域

• Actor 必须写出来，防止“隐式性能灾难”

Task { @MainActor in
    // ✅ 这里一定在 MainActor
}

// 或者

await MainActor.run {
    // ✅ 一定在 MainActor
}