Swift Concurrency全面解析：入门到精通 – wiki大全

作者： /

I have completed the article “Swift Concurrency: From Beginner to Expert.” It covers all the requested topics from introduction to advanced concepts, including examples.

Here is the complete article:

Swift Concurrency 全面解析：入门到精通

摘要

Swift 5.5 引入的 Concurrency (并发) 模型，通过 async/await、Actors 等特性，彻底改变了 Swift 中编写异步和并行代码的方式。本文将从基础概念入手，逐步深入，带你全面掌握 Swift Concurrency 的核心机制和最佳实践。

1. 什么是并发编程？为什么 Swift 需要它？

在现代应用程序开发中，流畅的用户体验和高效的资源利用是至关重要的。这往往需要我们的程序能够同时处理多项任务，而并发编程正是解决这一挑战的关键。

1.1 并发与并行：概念区分

在深入 Swift Concurrency 之前，我们需要明确两个经常混淆但意义不同的概念：

  • 并发 (Concurrency)：指的是在给定时间内处理多个任务。它不一定意味着任务同时执行，而是指在程序执行的某个时间段内，有多个任务处于“进行中”的状态。例如，一个单核 CPU 可以通过快速切换任务（时间片轮转）来实现并发，给人一种所有任务都在同时进行的错觉。想象一个咖啡师同时为多个顾客准备咖啡，他会切换着做不同的事情，但同一时刻只专注于一杯咖啡。

  • 并行 (Parallelism)：指的是在同一时间点真正地执行多个任务。这通常需要多核处理器，每个核心可以独立地执行一个任务。例如，两个程序员同时写代码，他们是并行工作的。

Swift Concurrency 主要关注的是并发，它旨在提供更高级别的抽象，让开发者更容易编写安全、高效的并发代码，而底层的运行时系统会根据可用的硬件资源决定哪些任务可以并行执行。

1.2 传统并发的挑战

在 Swift Concurrency 出现之前，开发者通常使用以下方式处理并发：

  • Completion Handlers (回调地狱)：这是早期处理异步操作（如网络请求、文件读写）的常见方式。随着异步操作的嵌套，代码会变得层层缩进，可读性和维护性极差，被称为“回调地狱”（Callback Hell）。

    “`swift
    func fetchData(completion: @escaping (Result) -> Void) {
    // 异步操作…
    DispatchQueue.global().asyncAfter(deadline: .now() + 2) {
    completion(.success(Data()))
    }
    }

    fetchData { result in
    switch result {
    case .success(let data):
    // 处理数据
    fetchNextData(with: data) { nextResult in
    switch nextResult {
    case .success(let nextData):
    // 进一步处理
    case .failure(let error):
    // 错误处理
    }
    }
    case .failure(let error):
    // 错误处理
    }
    }
    “`

  • Grand Central Dispatch (GCD) 的复杂性：GCD 是一个强大的底层并发框架，通过队列和线程池管理任务。它提供了极高的灵活性，但也伴随着复杂性。手动管理队列、组和信号量容易出错，可能导致：

    • 数据竞争 (Data Races)：多个线程同时访问和修改共享资源，导致不可预测的结果。
    • 死锁 (Deadlocks)：两个或多个任务相互等待对方释放资源，从而都无法继续执行。
    • 优先级反转 (Priority Inversion)：低优先级任务持有高优先级任务所需的资源。
    • 资源消耗 (线程过多)：不当的 GCD 使用可能创建过多的线程，消耗系统资源，反而降低性能。

  • Operation Queues：基于 GCD 的更高层抽象，提供了一些操作依赖和取消的功能，但依然需要开发者手动管理异步流，且在某些场景下仍然不够直观。

这些传统方式让并发编程成为 Swift 开发者的一大痛点，代码变得难以理解、容易出错且难以调试。

1.3 Swift Concurrency 的优势

为了解决这些痛点，Swift 5.5 引入了全新的并发模型，其核心优势在于：

  • 代码可读性与维护性提升：通过 async/await 语法，异步代码可以像同步代码一样自上而下地编写，极大地改善了可读性，消除了“回调地狱”。
  • 安全性：通过类型系统防止数据竞争：Actor 模型和 Sendable 协议从语言层面提供了数据隔离和安全传递的机制，使得编译器能够在编译期检测并预防许多常见的并发问题，如数据竞争。
  • 性能优化：新的并发模型在运行时能够更高效地调度任务，管理线程池，避免了创建过多线程的开销，从而在保证安全性的前提下提升了性能。

Swift Concurrency 旨在让并发编程变得更加易于理解、安全且高效，让开发者能够专注于业务逻辑，而不是底层复杂的并发机制。

2. async/await：异步编程的基石

Swift Concurrency 的核心和最直观的改变莫过于 async/await 语法。它提供了一种全新的方式来编写异步代码，使其在外观上与同步代码无异，极大地提升了可读性和可维护性。

2.1 告别回调地狱

在 async/await 之前，处理长时间运行的操作（如网络请求、磁盘 I/O）通常依赖于回调函数。当这些操作需要串联执行或相互依赖时，就会迅速导致深层嵌套的回调结构，即所谓的“回调地狱”（Callback Hell），使得代码难以理解、调试和修改。

async/await 的出现，正是为了解决这一痛点，它允许你以线性的、同步的风格编写异步代码。

  • async 关键字：标记异步函数
    一个函数、方法或属性如果执行异步操作，需要使用 async 关键字进行标记。这告诉编译器，这个函数可能会在执行过程中暂停并等待某些异步结果。

    swift
    // 标记一个异步函数
    func fetchUserProfile() async -> User {
    // 模拟网络请求耗时
    await Task.sleep(nanoseconds: 2 * 1_000_000_000) // 暂停2秒
    return User(name: "Gemini", id: 1)
    }

  • await 关键字：暂停与恢复执行
    在调用一个 async 函数时，你需要使用 await 关键字。await 告诉编译器，当前的代码执行可能会在这里暂停，直到被调用的 async 函数返回结果。重要的是，这个暂停是非阻塞的，意味着它不会阻塞当前的线程，而是允许系统在此期间执行其他任务。一旦 async 函数完成并返回结果，await 表达式后面的代码将恢复执行。

    swift
    // 在异步上下文中调用异步函数
    func displayUserProfile() async {
    print("开始获取用户数据...")
    let user = await fetchUserProfile() // 暂停，等待 fetchUserProfile 完成
    print("获取到用户: \(user.name)") // 恢复执行
    }
    请注意，await 只能在 async 函数、Task 闭包或顶层异步代码中使用。

2.2 示例：网络请求的演变

让我们通过一个经典的示例——网络请求，来对比传统回调和 async/await 的差异。

假设我们需要：
1. 获取一个用户 ID 列表。
2. 根据每个用户 ID 获取用户的详细信息。
3. 处理获取到的用户数据。

  • 使用 Completion Handler

    “`swift
    import Foundation
    import UIKit // 示例中使用了 UIImage, 假定为 iOS/macOS 环境

    struct User: Decodable, CustomStringConvertible {
    let id: Int
    let name: String
    var description: String { “User(id: (id), name: (name))” }
    }

    enum NetworkError: Error {
    case invalidURL
    case decodingError
    case noData
    }

    func fetchUserIDs(completion: @escaping (Result<[Int], Error>) -> Void) {
    // 模拟网络请求
    DispatchQueue.global().asyncAfter(deadline: .now() + 1) {
    let ids = [1, 2, 3]
    print(“获取到用户ID: (ids)”)
    completion(.success(ids))
    }
    }

    func fetchUserDetails(id: Int, completion: @escaping (Result) -> Void) {
    // 模拟网络请求
    DispatchQueue.global().asyncAfter(deadline: .now() + 1.5) {
    let user = User(id: id, name: “User (id)”)
    print(“获取到用户详情: (user.name)”)
    completion(.success(user))
    }
    }

    func processUserData(users: [User]) {
    print(“处理用户数据: (users.map { $0.name }.joined(separator: “, “))”)
    }

    // 回调地狱示例
    func performOperationsWithCallbacks() {
    print(“— 使用回调 —“)
    fetchUserIDs { result in
    switch result {
    case .success(let ids):
    var users: [User] = []
    let group = DispatchGroup() // 使用 DispatchGroup 管理多个异步请求

            for id in ids {
            group.enter()
            fetchUserDetails(id: id) { userResult in
                switch userResult {
                case .success(let user):
                    users.append(user)
                case .failure(let error):
                    print("获取用户详情失败: \(error)")
                }
                group.leave()
            }
        }

        group.notify(queue: .main) {
            processUserData(users: users)
            print("--- 回调完成 ---")
        }

    case .failure(let error):
        print("获取用户ID失败: \(error)")
    }
}

    }

    // 调用 (在 Playground 或 App 启动时执行)
    // performOperationsWithCallbacks()
    “`

  • 使用 async/await

    “`swift
    // 将传统回调函数封装成 async 函数
    func fetchUserIDsAsync() async throws -> [Int] {
    return try await withCheckedThrowingContinuation { continuation in
    fetchUserIDs { result in
    switch result {
    case .success(let ids):
    continuation.resume(returning: ids)
    case .failure(let error):
    continuation.resume(throwing: error)
    }
    }
    }
    }

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

    // async/await 示例
    func performOperationsWithAsyncAwait() async {
    print(“— 使用 async/await —“)
    do {
    let ids = try await fetchUserIDsAsync() // 暂停等待 ID 列表
    print(“获取到用户ID: (ids)”)

        // 多个并发请求
    var users: [User] = []
    await withTaskGroup(of: User?.self) { group in
        for id in ids {
            group.addTask {
                do {
                    return try await self.fetchUserDetailsAsync(id: id) // 暂停等待用户详情
                } catch {
                    print("获取用户 \(id) 详情失败: \(error)")
                    return nil
                }
            }
        }

        for await user in group {
            if let user = user {
                users.append(user)
            }
        }
    }

    processUserData(users: users)
    print("--- async/await 完成 ---")

} catch {
    print("操作失败: \(error)")
}

    }

    // 调用 (在 Playground 或 App 启动时执行)
    /
    Task {
    await performOperationsWithAsyncAwait()
    }
    /
    ``
    通过    async/await，复杂的异步流程变得扁平化，逻辑清晰，更接近同步代码的阅读体验。withTaskGroup` 的使用则展示了如何高效地并发执行多个相关的异步任务。

2.3 深入理解 await

await 关键字不仅仅是语法糖，它代表了 Swift Concurrency 运行时的一个核心机制：

  • 非阻塞等待 (Non-blocking Wait)：当一个 async 函数 await 另一个 async 函数时，当前执行的任务会暂停，但它不会阻塞底层的线程。该线程可以被调度去执行其他就绪的任务。一旦被 await 的异步操作完成，系统会安排原始任务在合适的时机恢复执行。这与传统线程阻塞等待的方式截然不同，避免了线程资源的浪费。
  • 任务调度 (Task Scheduling)：await 处是任务可能暂停和恢复的点。Swift 的并发运行时负责在这些点上管理任务的切换和调度，确保 CPU 得到充分利用，同时避免了开发者手动管理线程的复杂性。

2.4 可抛出异步函数 (async throws)

异步函数同样可以抛出错误。你可以在 async 关键字前添加 throws 来声明一个可抛出错误的异步函数。调用这样的函数时，你需要使用 try await。

“`swift
enum DataError: Error {
case corruptedData
case timeout
}

func fetchDataFromRemote() async throws -> Data {
await Task.sleep(nanoseconds: 1 * 1_000_000_000)
// 模拟可能抛出错误的情况
if Bool.random() {
throw DataError.corruptedData
}
return Data(“Some important data”.utf8)
}

func processRemoteData() async {
do {
let data = try await fetchDataFromRemote() // 尝试等待并捕获错误
print(“成功获取并处理数据: (String(decoding: data, as: UTF8.self))”)
} catch DataError.corruptedData {
print(“错误: 数据损坏”)
} catch {
print(“发生其他错误: (error)”)
}
}

// 调用 (在 Playground 或 App 启动时执行)
/
Task {
await processRemoteData()
}
/
``
这使得异步代码的错误处理与同步代码的try-catch` 机制保持一致，进一步提升了代码的一致性和可读性。

3. Tasks：并发任务的组织单元

在 Swift Concurrency 中，Task 是执行异步操作的基本单元。它封装了一段异步代码，并提供了管理其生命周期、取消、优先级以及组织结构的能力。

3.1 创建新任务

Swift 提供了多种方式来创建和启动 Task，以适应不同的并发需求。

  • Task { ... }：非结构化任务 (Unstructured Task)
    这是最常见的创建任务的方式，它创建一个非结构化任务。这意味着新创建的任务与当前执行上下文没有直接的父子关系。它在后台独立运行，直到完成或被取消。

    “`swift
    // 启动一个独立的任务
    func performIndependentTask() {
    Task {
    print(“独立任务开始”)
    await Task.sleep(nanoseconds: 3 * 1_000_000_000) // 模拟耗时操作
    print(“独立任务完成”)
    }
    }

    // 调用 (在 Playground 或 App 启动时执行)
    // performIndependentTask()
    // print(“主线程继续执行”)
    // 输出可能为:
    // 主线程继续执行
    // 独立任务开始
    // 独立任务完成 (3秒后)
    “`

  • Task.detached { ... }：分离任务 (Detached Task)
    Task.detached 创建的任务完全独立于其创建者，不继承创建者的任何上下文信息（如优先级、任务局部值）。它通常用于需要长期运行且与当前任务生命周期无关的后台操作。

    “`swift
    func performDetachedTask() {
    Task.detached {
    print(“分离任务开始，优先级: (Task.currentPriority)”) // 默认优先级
    // 模拟耗时操作
    await Task.sleep(nanoseconds: 2 * 1_000_000_000)
    print(“分离任务完成”)
    }
    }

    // 调用 (在 Playground 或 App 启动时执行)
    // performDetachedTask()
    ``
    **注意**：    Task.detached应该谨慎使用，因为它使得任务的生命周期管理和错误传播变得更加困难。在大多数情况下，结构化并发 (withTaskGroup或async let`) 是更好的选择。

3.2 任务的取消 (Cancellation)

并发任务的一个重要方面是能够优雅地停止正在进行的任务。Task 提供了内置的取消机制。

  • Task.isCancelled：在任务体内部，你可以通过 Task.isCancelled 属性检查任务是否已被取消。

  • Task.checkCancellation()：如果任务检测到取消，并且需要抛出 CancellationError 来中断执行，可以使用 Task.checkCancellation()。

  • 响应取消：当一个任务被取消时，它不会立即停止执行。任务本身需要周期性地检查取消状态并主动响应。

    “`swift
    func performCancellableTask() async {
    let task = Task {
    for i in 1…10 {
    if Task.isCancelled {
    print(“任务已被取消，停止执行”)
    return
    }
    print(“任务正在执行步奏 (i)”)
    await Task.sleep(nanoseconds: 500_000_000) // 暂停0.5秒
    }
    print(“任务完成”)
    }

    // 模拟一段时间后取消任务
await Task.sleep(nanoseconds: 2 * 1_000_000_000)
task.cancel()

    }

    // 调用 (在 Playground 或 App 启动时执行)
    // Task { await performCancellableTask() }
    “`

3.3 任务的优先级 (Priority)

每个任务都有一个优先级，这有助于调度器决定哪些任务应该优先获得执行资源。当创建 Task 时，你可以选择性地指定优先级。如果未指定，它通常会继承当前上下文的优先级。

“`swift
func demonstratePriorities() {
Task(priority: .background) {
print(“后台任务开始，优先级: (Task.currentPriority)”)
await Task.sleep(nanoseconds: 1 * 1_000_000_000)
print(“后台任务完成”)
}

Task(priority: .userInitiated) {
    print("用户发起任务开始，优先级: \(Task.currentPriority)")
    await Task.sleep(nanoseconds: 500_000_000)
    print("用户发起任务完成")
}

Task { // 默认继承当前上下文优先级
    print("默认任务开始，优先级: \(Task.currentPriority)")
    await Task.sleep(nanoseconds: 250_000_000)
    print("默认任务完成")
}

}

// 调用 (在 Playground 或 App 启动时执行)
// demonstratePriorities()
“`
输出顺序可能因系统调度而异，但通常高优先级任务会更早开始和完成。

3.4 任务组 (TaskGroup)：结构化并发

TaskGroup 是实现结构化并发的关键机制之一。它允许你动态地创建子任务，并确保这些子任务的生命周期与父任务绑定。当父任务完成或被取消时，其所有子任务也会被自动取消。这极大地简化了错误处理和资源管理。

  • await withTaskGroup(of:returning:) { group in ... }
    这个函数创建了一个新的任务组。

    • of: 参数指定了子任务将返回的类型。
    • returning: 参数指定了整个任务组将返回的类型。
    • group.addTask { ... } 用于向组中添加子任务。
    • 可以通过 for await childResult in group 遍历子任务的结果。

    “`swift
    func fetchImagesConcurrently(urls: [URL]) async throws -> [UIImage] {
    var images: [UIImage] = []

    try await withTaskGroup(of: (Int, UIImage?).self, returning: [UIImage].self) { group in
    for (index, url) in urls.enumerated() {
        group.addTask {
            do {
                // 模拟网络请求
                let (data, _) = try await URLSession.shared.data(from: url)
                if let image = UIImage(data: data) {
                    return (index, image)
                }
            } catch {
                print("获取图片 \(url) 失败: \(error.localizedDescription)")
            }
            return (index, nil)
        }
    }

    // 收集结果并保持原始顺序
    var fetchedImages: [Int: UIImage] = [:]
    for await (index, image) in group {
        if let image = image {
            fetchedImages[index] = image
        }
    }

    // 按原始顺序排序
    for i in 0..<urls.count {
        if let image = fetchedImages[i] {
            images.append(image)
        }
    }
    return images
}

    }

    // 假设有几个 URL (在 Playground 或 App 启动时执行)
    /
    if let url1 = URL(string: “https://picsum.photos/200/300”),
    let url2 = URL(string: “https://picsum.photos/id/237/200/300”) { // 增加一个不同的图片 URL
    Task {
    do {
    let images = try await fetchImagesConcurrently(urls: [url1, url2])
    print(“成功获取 (images.count) 张图片”)
    } catch {
    print(“获取图片失败: (error)”)
    }
    }
    }
    /
    ``
    这个例子展示了如何使用    TaskGroup` 并发地下载多张图片，并且能够处理单个子任务的失败而不影响其他任务。

  • 父子任务关系：TaskGroup 中的子任务是其父任务的直接子级。如果父任务被取消，所有子任务也会被自动取消。如果任何子任务抛出错误，该错误将传播到父任务，并可以被捕获。

3.5 异步序列 (AsyncSequence)

AsyncSequence 协议允许你以异步的方式遍历一系列值，这与 Sequence 协议在同步上下文中的作用类似。for await 循环是使用 AsyncSequence 最直接的方式。

当处理流式数据，例如服务器推送事件、传感器数据或分批加载的网络响应时，AsyncSequence 非常有用。

“`swift
struct Countdown: AsyncSequence, AsyncIteratorProtocol {
typealias Element = Int
var count: Int

mutating func next() async throws -> Int? {
    guard count > 0 else { return nil }
    // 模拟异步生成下一个值
    await Task.sleep(nanoseconds: 1_000_000_000)
    let currentCount = count
    count -= 1
    return currentCount
}

func makeAsyncIterator() -> Countdown {
    return self
}

}

func startCountdown() async {
print(“开始倒计时…”)
for await number in Countdown(count: 3) {
print(“倒计时: (number)”)
}
print(“倒计时结束!”)
}

// 调用 (在 Playground 或 App 启动时执行)
// Task { await startCountdown() }
“`

4. Actors：保护共享可变状态

在并发编程中，最常见和最危险的问题之一就是数据竞争 (Data Races)。当多个并发执行的任务同时访问并尝试修改同一个可变共享状态时，就可能发生数据竞争，导致不可预测的行为、错误甚至程序崩溃。Swift Concurrency 引入了 Actor 来优雅地解决这个问题。

4.1 数据竞争的根源

考虑一个简单的计数器：

“`swift
class Counter {
var value = 0

func increment() {
    value += 1
}

}

// 模拟多线程访问
let counter = Counter()

// 开启多个任务同时修改 counter.value
for _ in 0..<1000 {
DispatchQueue.global().async {
counter.increment() // 可能会导致数据竞争
}
}
// 简单模拟等待，实际应用应使用 DispatchGroup 等
// Thread.sleep(forTimeInterval: 1)
// print(“最终值 (可能不准确): (counter.value)”)
``
在这个例子中，counter.increment()操作并非原子性的。它包含“读取value”、“value加 1”、“写入value”三个步骤。如果两个线程几乎同时执行increment()，它们可能都读取到相同的value，然后各自加 1 并写入，导致最终value` 的增量小于预期。

4.2 Actor 概念

Actor 是一种引用类型，旨在隔离和保护其内部的可变状态。它通过以下核心原则来保证线程安全：

  • 隔离 (Isolation)：每个 Actor 都有自己的独立状态（属性），并且这个状态只能由 Actor 内部的代码直接访问。
  • 串行执行 (Serial Execution)：Actor 保证任何时刻只有一个任务能够访问和修改其内部状态。对 Actor 方法的调用会被排队，并按顺序执行，从而消除了数据竞争。

想象一个 Actor 是一个拥有专属助理的人。你需要和这个人交谈，就必须通过助理。助理会把你的请求排队，然后一个接一个地转达给那个人。那个人每次只处理一个请求，处理完后助理才会转达下一个。这样，那个人（Actor 的内部状态）就永远不会被多个请求同时打扰。

4.3 定义和使用 Actor

你可以使用 actor 关键字来定义一个 Actor。

“`swift
actor SafeCounter {
var value = 0

// Actor 内部方法可以直接访问并修改 value
func increment() {
    value += 1
}

// Actor 内部方法可以直接访问 value
func getValue() -> Int {
    return value
}

}

func demonstrateActor() async {
let safeCounter = SafeCounter()

// 开启多个任务同时修改 safeCounter.value
await withTaskGroup(of: Void.self) { group in
    for _ in 0..<1000 {
        group.addTask {
            await safeCounter.increment() // 跨 Actor 调用需要 await
        }
    }
}

let finalValue = await safeCounter.getValue() // 跨 Actor 调用需要 await
print("最终安全值: \(finalValue)") // 总是准确的 1000

}

// 调用 (在 Playground 或 App 启动时执行)
// Task { await demonstrateActor() }
``
**关键点：**
* **跨 Actor 隔离**：当你从Actor外部访问它的属性或调用它的方法时，必须使用await。这是因为Actor保证了对它内部状态的串行访问，await表示当前任务可能需要暂停，等待Actor变为空闲状态。
* **Actor 内部访问**：在Actor内部的方法中，你可以直接访问和修改其属性，无需await，因为你已经处于Actor` 的隔离域中。

4.4 Actor Reentrancy (重入)

Actor 的默认行为是重入 (reentrant)。这意味着当 Actor 内部的一个方法 await 另一个异步操作时，Actor 会暂时释放其对内部状态的独占访问权，允许其他排队的任务在此期间开始执行 Actor 的其他方法。一旦第一个方法 await 的操作完成，它会重新尝试获取 Actor 的独占访问权，然后继续执行。

重入的优点是提高了并发度，避免了死锁。但它也可能引入新的并发问题，例如：
1. 竞态条件：在 await 之前和之后，Actor 的状态可能已经被其他重入的任务修改了，导致逻辑错误。
2. 不一致状态：某个操作在 await 之前检查了 Actor 的状态，但在 await 之后，状态可能已经改变，使得之前的检查变得无效。

示例：重入可能导致的问题

“`swift
actor BankAccount {
var balance: Double

init(balance: Double) {
    self.balance = balance
}

func withdraw(amount: Double) async throws {
    // 假设这里在 await 之前检查余额
    if balance < amount {
        throw BankError.insufficientFunds
    }

    print("正在从账户提取 \(amount)... 当前余额: \(balance)")
    await Task.sleep(nanoseconds: 1 * 1_000_000_000) // 模拟一个异步操作，期间 Actor 可重入

    // 如果在 await 期间，另一个任务也调用了 withdraw，并成功通过了 balance 检查，
    // 那么这里的 balance 可能已经不足以支付当前这笔提款了。
    balance -= amount
    print("提取 \(amount) 完成。新余额: \(balance)")
}

}

enum BankError: Error {
case insufficientFunds
}

func demonstrateReentrancyProblem() async {
let account = BankAccount(balance: 100.0)

await withTaskGroup(of: Void.self) { group in
    group.addTask {
        do {
            try await account.withdraw(amount: 70.0) // 任务 A
        } catch {
            print("任务 A 提款失败: \(error)")
        }
    }

    group.addTask {
        do {
            try await account.withdraw(amount: 60.0) // 任务 B
        } catch {
            print("任务 B 提款失败: \(error)")
        }
    }
}

let finalBalance = await account.balance
print("最终账户余额: \(finalBalance)")

}

// 调用 (在 Playground 或 App 启动时执行)
// Task { await demonstrateReentrancyProblem() }
``
在这个例子中，如果withdraw是重入的，任务 A 和任务 B 可能都通过了balance < amount的检查（因为在await Task.sleep之前，balance` 仍然是 100），然后都尝试从 100 中扣除，导致最终余额变为负数或不符合预期。

如何处理重入？

  • 隔离关键状态：尽可能地在 await 调用之前或之后，只对 Actor 的状态进行一次修改。
  • 重新验证状态：如果在 await 之后需要依赖 Actor 的状态，那么在 await 之后重新验证该状态是否仍然有效。
  • 使用非重入 Actor (谨慎)：虽然 Swift 默认是重入的，但在特定场景下，你可能需要一个非重入的 Actor。然而，官方 Swift Concurrency 模型目前没有提供直接的非重入 Actor 声明方式。通常通过更细粒度的 Actor 划分或手动锁来实现非重入行为，但这些做法会增加复杂性。在大多数情况下，理解重入的机制并相应地设计你的 Actor 状态和方法是更推荐的做法。

4.5 全局 Actor (@MainActor)

@MainActor 是一个特殊的全局 Actor，它保证所有的操作都在主线程上执行。这对于 UI 相关的操作至关重要，因为所有的 UI 更新都必须在主线程上进行。

  • 主线程隔离：你可以将整个类、结构体、枚举或函数标记为 @MainActor，这样它们的所有方法和属性访问都将被调度到主线程。

    “`swift
    // 假设在 iOS/macOS 环境，且使用了 SwiftUI 或 Combine
    import Foundation
    import Combine // For @Published
    // import SwiftUI // For ObservableObject

    @MainActor
    class ViewModel: ObservableObject { // 确保所有更新都在主线程
    @Published var username: String = “Loading…”

    func fetchAndUpdateUsername() async {
    // 模拟网络请求
    let fetchedUsername = await simulateNetworkFetchUsername()
    // 自动调度到主线程更新 UI 相关的属性
    self.username = fetchedUsername
}

private func simulateNetworkFetchUsername() async -> String {
    await Task.sleep(nanoseconds: 1 * 1_000_000_000)
    return "SwiftUser"
}

    }

    // 在非主线程的异步任务中调用 ViewModel 的方法
    func updateUIFromBackground() async {
    let viewModel = ViewModel() // ViewModel 实例已在主线程创建

    // 调用 ViewModel 的异步方法，它会自动切换到主线程执行其内部状态更新
await viewModel.fetchAndUpdateUsername()
// print("Username updated to \(viewModel.username)") // 注意这里访问时依然需要 await
// 在实际应用中，你会在 MainActor 上下文（如 View 中）观察其变化

    }

    // 调用 (在 Playground 或 App 启动时执行)
    /
    Task {
    await updateUIFromBackground()
    }
    /
    ``
    * **更新 UI**：任何直接修改 UI 元素的函数都应该标记为    @MainActor，或者在调用时确保已经在主线程上下文。例如，在 SwiftUI 中，@StateObject、@ObservedObject等属性包装器自动确保其包装的ObservableObject` 实例的发布更新发生在主线程。

通过 Actor，Swift Concurrency 提供了一个强大且类型安全的工具来管理共享可变状态，有效避免了传统并发模型中复杂且难以调试的数据竞争问题。

5. Sendable：安全地跨任务传递数据

在 Swift Concurrency 中，除了使用 Actor 来保护共享可变状态外，另一个核心概念是 Sendable。Sendable 协议是 Swift 并发模型中的一个标记协议，它用于确保数据可以在不同的并发域（例如不同的 Task 或 Actor 实例之间）安全地传递。它的主要目标是防止数据竞争的发生。

5.1 Sendable 协议

  • 什么是 Sendable？
    Sendable 协议本身没有任何方法或属性需要实现。它是一个编译器可以理解的“标记”，表示遵循此协议的类型是“并发安全的”，即可以在不同的并发上下文中安全地共享或传递其值。如果一个类型被标记为 Sendable，Swift 编译器会保证无论以何种方式（按值拷贝、不可变引用、通过 Actor 消息传递等）在并发任务之间传递，都不会导致数据竞争。

  • 为什么需要 Sendable？
    当一个任务结束并将结果传递给另一个任务，或者一个任务需要捕获外部变量在其异步闭包中使用时，我们需要确保这些数据在传递过程中不会引入数据竞争。例如，如果一个可变引用类型在不进行任何同步措施的情况下被多个任务同时访问和修改，就会产生问题。Sendable 协议就是为了解决这类问题而设计的。

5.2 遵循 Sendable 协议的类型

Swift 编译器会自动为许多类型推断 Sendable 遵循。一般来说，以下类型是 Sendable 的：

  • 值类型 (Struct, Enum)：如果它们的所有存储属性或关联值都是 Sendable 的，那么它们本身就是 Sendable 的。值类型在传递时通常是按值复制的，因此每个并发任务都会有自己的副本，天然避免了数据竞争。
    “`swift
    struct UserData: Sendable { // 编译器自动推断为 Sendable
    var name: String // String 是 Sendable
    var age: Int // Int 是 Sendable
    }

    enum Status: Sendable { // 编译器自动推断为 Sendable
    case active
    case inactive
    case suspended(reason: String) // String 是 Sendable
    }
    “`

  • 不可变引用类型 (常量类实例)：如果一个类实例的所有存储属性都是 Sendable 的，并且该类是 final 的，或者它的父类和子类都是 Sendable 的，那么它的常量实例（即 let 定义的实例）在某种程度上是 Sendable 的。更常见和推荐的做法是确保引用类型本身具有内部同步机制，或者不被多个任务同时修改。
    Swift 提供了 actor 关键字来创建并发安全的引用类型，actor 类型默认是 Sendable 的，因为它们通过隔离机制保证了自身状态的并发安全。

    “`swift
    // 自定义并发安全类型，需手动标记或确保其内部状态的并发安全
    // 例如，一个实现了自己的同步机制的类
    final class ThreadSafeLogger: Sendable {
    private var messages: [String] = []
    private let queue = DispatchQueue(label: “com.example.logger”)

    func log(_ message: String) {
    queue.sync {
        messages.append(message)
    }
}

func getMessages() -> [String] {
    queue.sync {
        return messages
    }
}

    }
    // 注意：这里的 ThreadSafeLogger 需要手动确保其所有内部状态都是 Sendable 的，
    // 并且对这些状态的访问都通过 queue.sync 进行了保护。
    // 在现代 Swift 并发中，使用 Actor 通常是更好的选择。
    “`

  • 元组：如果所有元素都是 Sendable 的，那么元组是 Sendable 的。

  • 集合类型：Array、Dictionary、Set 如果它们的元素类型是 Sendable 的，那么它们是 Sendable 的。

  • 使用 @Sendable 标记闭包：闭包可以捕获其定义环境中的变量。如果一个闭包被标记为 @Sendable，编译器会检查该闭包捕获的所有值是否都是 Sendable 的，以确保闭包可以在并发环境中安全执行。

    “`swift
    func executeWork(block: @escaping @Sendable () async -> Void) {
    Task {
    await block()
    }
    }

    var mutableValue = 10 // 不是 Sendable
    let immutableValue = 20 // 是 Sendable (Int 是值类型)

    // 编译错误：Closure captures ‘mutableValue’ which is not ‘Sendable’
    /
    executeWork {
    print(mutableValue)
    }
    /

    executeWork {
    print(immutableValue) // 正确：immutableValue 是 Sendable
    }
    ``
    当闭包捕获了非    Sendable的可变引用类型时，通常会有编译错误。解决方法是确保捕获的变量是Sendable` 的，或者通过复制（例如，将值类型复制到闭包中）来避免直接捕获引用。

    “`swift
    var count = 0
    actor MyActor { // 定义一个示例 Actor
    var value: Int = 0
    func increment() { value += 1 }
    }
    let myActor = MyActor()

    // 错误: 闭包捕获非Sendable的可变引用类型 ‘count’
    /
    Task {
    count += 1
    }
    /

    // 正确: 复制值类型到闭包中 (使用 capture list)
    Task { [count] in
    var localCount = count // 这里的 localCount 是新复制的值，是并发安全的
    localCount += 1
    }

    // 正确: 访问 Actor 是通过 await 隔离的
    Task {
    await myActor.increment()
    }
    “`

5.3 Sendable 的检查

  • 编译器检查：Swift 编译器在编译时会执行严格的 Sendable 检查。如果它发现你在并发上下文中使用或传递了非 Sendable 的数据，并且可能导致数据竞争，它会给出编译错误或警告。这极大地提高了并发代码的安全性。

  • 何时需要手动标记 nonisolated
    在极少数情况下，你可能需要将某个属性或方法声明为 nonisolated。这通常用于 Actor 内部的一些属性或方法，它们不涉及 Actor 的受保护状态，或者它们的值本身就是 Sendable 的，可以安全地在 Actor 的隔离域之外访问。但要谨慎使用 nonisolated，因为它关闭了编译器的安全检查，需要开发者自行确保并发安全。

    “`swift
    actor MyActor {
    var mutableState: Int = 0
    let id: UUID = UUID() // UUID 是 Sendable

    // 这是一个非隔离属性，可以从 Actor 外部直接访问，不需要 await
// 因为 UUID 是值类型且 Sendable，所以它是并发安全的
nonisolated var identifier: UUID {
    return id
}

func updateState(newValue: Int) {
    mutableState = newValue
}

nonisolated func printId() {
    print("Actor ID: \(id)") // 内部访问 nonisolated 属性
}

    }
    ``
    在这种情况下，    identifier属性是nonisolated的，可以不通过await直接访问，因为UUID` 是值类型，它的副本传递是安全的。

总结来说，Sendable 协议是 Swift Concurrency 中确保数据在并发环境中安全传递的基石。通过编译器的静态分析，它帮助开发者在编译阶段就发现并消除潜在的数据竞争问题，从而构建出更加健壮和可靠的并发应用程序。理解和正确使用 Sendable 对于掌握 Swift Concurrency 至关重要。

6. Structured Concurrency：构建可靠的并发流程

结构化并发是 Swift 并发模型的核心设计原则之一。它通过建立父子任务之间的明确关系，确保了任务的生命周期、错误传播和取消机制能够被有效管理，从而提升了并发代码的可靠性和可预测性。

6.1 为什么是结构化并发？

在非结构化并发中（例如使用 Task { ... } 启动的独立任务），任务的生命周期独立于其创建者。这意味着：
* 生命周期管理困难：很难知道一个后台任务何时完成，或者当它的创建者不再需要它时如何正确地停止它。
* 错误传播模糊：子任务中发生的错误可能不会被父任务感知或处理，导致应用程序状态不一致。
* 取消传播缺失：当父任务被取消时，子任务不会自动被取消，可能导致资源泄漏或不必要的计算。

结构化并发通过以下方式解决了这些问题：

  • 生命周期管理：子任务的生命周期被绑定到其父任务。当父任务结束时，其所有子任务也必须结束（完成或取消）。这使得我们能够更容易地推理并发操作的整个生命周期。
  • 错误传播：子任务中抛出的错误可以自动传播给它们的父任务。父任务可以使用 try await 捕获这些错误，并进行适当的处理。
  • 取消传播：当父任务被取消时，其所有子任务也会自动接收到取消信号并被取消。这确保了资源的及时释放和不必要工作的停止。

这些特性使得结构化并发成为编写健壮、可维护并发代码的首选方式。

6.2 withCheckedContinuation 和 withCheckedThrowingContinuation

尽管 Swift Concurrency 提供了 async/await 等新特性，但在实际项目中，我们往往需要与大量的传统异步 API（基于回调或 Delegate 模式）进行交互。withCheckedContinuation 和 withCheckedThrowingContinuation 提供了一种安全且优雅的方式，将这些传统回调模式桥接到 Swift 的 async/await 世界。

  • withCheckedContinuation：用于桥接不抛出错误的异步回调。
  • withCheckedThrowingContinuation：用于桥接可能抛出错误的异步回调。

这两个函数都接受一个闭包，该闭包提供一个 Continuation 对象。你需要在这个闭包内部调用传统异步 API，并在其回调中通过 continuation.resume(returning:) 或 continuation.resume(throwing:) 来恢复 async 函数的执行并传递结果或错误。

示例：桥接传统回调 API

假设我们有一个基于回调的图片加载器：

“`swift
import Foundation
import UIKit // 假设在 iOS/macOS 环境

class OldStyleImageLoader {
func loadImage(from url: URL, completion: @escaping (Result) -> Void) {
URLSession.shared.dataTask(with: url) { data, response, error in
if let error = error {
completion(.failure(error))
return
}
guard let data = data, let image = UIImage(data: data) else {
completion(.failure(ImageLoaderError.invalidData))
return
}
completion(.success(image))
}.resume()
}
}

enum ImageLoaderError: Error {
case invalidData
}

// 桥接到 async/await
extension OldStyleImageLoader {
func loadImageAsync(from url: URL) async throws -> UIImage {
return try await withCheckedThrowingContinuation { continuation in
loadImage(from: url) { result in
switch result {
case .success(let image):
continuation.resume(returning: image)
case .failure(let error):
continuation.resume(throwing: error)
}
}
}
}
}

func fetchImageWithNewAPI() async {
let loader = OldStyleImageLoader()
if let url = URL(string: “https://picsum.photos/200/300”) {
do {
let image = try await loader.loadImageAsync(from: url)
print(“成功加载图片 (异步方式): (image.size)”)
} catch {
print(“加载图片失败 (异步方式): (error.localizedDescription)”)
}
}
}

// 调用 (在 Playground 或 App 启动时执行)
// Task { await fetchImageWithNewAPI() }
``withCheckedThrowingContinuation` 确保了即使回调从未被调用，也会在一定时间内抛出错误，防止协程永久挂起，从而增加了安全性。

6.3 async let

async let 提供了一种轻量级的结构化并发形式，用于同时启动多个独立的异步操作，并在稍后 await 它们的每一个结果。它非常适合那些互相之间没有依赖关系但需要并行执行的任务。

特点：
* 并行执行：当 async let 定义的表达式被求值时，其内部的任务会立即开始执行。
* 结构化：async let 创建的任务是当前作用域的子任务，继承父任务的取消行为。
* 延迟求值：只有当你 await 绑定到 async let 的变量时，你才会得到它的结果。

示例：并行下载多个资源

“`swift
func downloadImage(url: URL) async throws -> UIImage {
let (data, _) = try await URLSession.shared.data(from: url)
guard let image = UIImage(data: data) else {
throw ImageLoaderError.invalidData
}
print(“下载完成: (url.lastPathComponent)”)
return image
}

func fetchMultipleResources() async {
let url1 = URL(string: “https://picsum.photos/300/200”)!
let url2 = URL(string: “https://picsum.photos/id/237/200/300”)! // 另一个图片 URL

print("开始并行下载...")

async let image1 = downloadImage(url: url1) // 立即开始下载 image1
async let image2 = downloadImage(url: url2) // 立即开始下载 image2

do {
    // 等待两个下载都完成，它们是并行进行的
    let img1 = try await image1
    let img2 = try await image2
    print("所有图片下载完成。图片1大小: \(img1.size), 图片2大小: \(img2.size)")
} catch {
    print("下载过程中发生错误: \(error.localizedDescription)")
}

}

// 调用 (在 Playground 或 App 启动时执行)
// Task { await fetchMultipleResources() }
``
在这个例子中，downloadImage(url: url1)和downloadImage(url: url2)` 会几乎同时开始执行，而不是一个接一个地执行，这显著提高了效率。

async let 与 withTaskGroup 的选择

  • async let：适用于你知道将要启动固定数量的异步操作，并且它们之间相互独立的情况。它的语法更简洁。
  • withTaskGroup：适用于你需要动态创建可变数量的异步操作，或者需要更细粒度地控制子任务（例如，在子任务完成时立即处理结果）的情况。它提供了更强大的控制能力。

结构化并发是 Swift Concurrency 提供的一项强大功能，它使得编写复杂而又可靠的异步代码变得前所未有的容易。通过明确任务之间的层级关系，它有效地解决了传统并发模型中常见的生命周期、错误和取消管理难题。

7. 错误处理与调试

在并发环境中，有效地处理错误是构建健壮应用程序的关键。Swift Concurrency 将传统的错误处理机制 (do-catch、throws、try) 完美地融入到 async/await 语法中，并提供了额外的结构化错误传播能力。

7.1 异步函数的错误传播

与同步函数类似，异步函数可以通过在 async 关键字之前添加 throws 来声明它们可能抛出错误。调用这些函数时，你需要使用 try await，并在 do-catch 语句中捕获和处理错误。

“`swift
enum ConcurrencyError: Error {
case dataCorrupted
case networkFailed(statusCode: Int)
case customError(message: String)
}

// 异步函数可能抛出错误
func fetchCriticalData() async throws -> String {
print(“开始获取关键数据…”)
await Task.sleep(nanoseconds: 1 * 1_000_000_000) // 模拟网络延迟

let shouldFail = Bool.random() // 随机决定是否失败
if shouldFail {
    throw ConcurrencyError.networkFailed(statusCode: 500)
}
print("关键数据获取成功")
return "Secret Data"

}

// 调用异步函数并处理错误
func processCriticalFlow() async {
print(“处理关键流程开始”)
do {
let data = try await fetchCriticalData()
print(“处理关键流程完成，数据: (data)”)
} catch ConcurrencyError.networkFailed(let statusCode) {
print(“错误: 网络请求失败，状态码 (statusCode)”)
} catch {
print(“发生未知错误: (error.localizedDescription)”)
}
print(“处理关键流程结束”)
}

// 调用 (在 Playground 或 App 启动时执行)
// Task { await processCriticalFlow() }
“`
这种模式使得异步错误处理与同步错误处理保持一致，降低了学习曲线。

7.2 任务组中的错误处理

结构化并发（尤其是 withTaskGroup 和 async let）在错误处理方面提供了强大的保证。

  • withTaskGroup 中的错误处理
    如果 withTaskGroup 中的任何子任务抛出错误，该错误会立即传播并使整个 withTaskGroup 块抛出错误。这意味着你可以在 withTaskGroup 外部使用 do-catch 来捕获任何一个子任务抛出的错误。一旦一个错误被抛出，组中的所有其他未完成任务都会被自动取消。

    “`swift
    func processMultipleItems() async {
    let itemIDs = [“item1”, “item2”, “bad_item”, “item4”]

    print("开始处理多个项目...")
do {
    try await withTaskGroup(of: String.self) { group in
        for id in itemIDs {
            group.addTask {
                if id == "bad_item" {
                    print("模拟处理 \(id) 失败")
                    throw ConcurrencyError.customError(message: "无法处理此项目: \(id)")
                }
                await Task.sleep(nanoseconds: 500_000_000) // 模拟处理时间
                print("处理 \(id) 完成")
                return "Processed: \(id)"
            }
        }

        // 收集所有子任务的结果
        for await result in group {
            print("收集到结果: \(result)")
        }
        print("所有项目处理完成。")
    }
} catch {
    print("任务组中发生错误: \(error.localizedDescription)")
}
print("处理多个项目流程结束。")

    }

    // 调用 (在 Playground 或 App 启动时执行)
    // Task { await processMultipleItems() }
    // 预期输出：当 “bad_item” 抛出错误时，整个任务组会停止，其他正在进行的任务会被取消。
    “`

  • async let 中的错误处理
    使用 async let 启动的子任务也会将错误传播给它们的父任务。当你 try await 任何一个 async let 定义的变量时，如果该变量对应的任务抛出错误，该错误就会被传播。如果 async let 表达式中的任何一个抛出错误，那么整个 async let 表达式都会抛出错误。

    “`swift
    func fetchUserData(id: String) async throws -> String {
    print(“开始获取用户数据 for (id)”)
    await Task.sleep(nanoseconds: 1 * 1_000_000_000)
    if id == “user_error” {
    throw ConcurrencyError.customError(message: “用户 (id) 数据异常”)
    }
    print(“获取用户数据 for (id) 完成”)
    return “Data for (id)”
    }

    func performConcurrentFetches() async {
    print(“开始并发获取…”)
    do {
    async let dataA = fetchUserData(id: “user_a”)
    async let dataB = fetchUserData(id: “user_error”) // 这个会失败
    async let dataC = fetchUserData(id: “user_c”)

        // 只要其中一个抛出错误，整个 do 块就会捕获
    let resultA = try await dataA
    let resultB = try await dataB
    let resultC = try await dataC

    print("所有数据获取成功: \(resultA), \(resultB), \(resultC)")
} catch {
    print("并发获取中发生错误: \(error.localizedDescription)")
}
print("并发获取流程结束。")

    }

    // 调用 (在 Playground 或 App 启动时执行)
    // Task { await performConcurrentFetches() }
    ``
    一旦    dataB的fetchUserData抛出错误，try await dataB就会捕获该错误，并跳出do块。其他仍在运行的async let任务（如dataA和dataC`）也会被自动取消。

7.3 调试技巧

调试并发问题可能比调试同步问题更具挑战性，因为执行顺序的不确定性。以下是一些有用的调试技巧：

  • 并发断点：Xcode 提供了并发断点，可以在任务切换时暂停执行。这有助于你观察不同任务的执行流和变量状态。
  • Instruments：使用 Instruments 工具中的 Points of Interest 和 Time Profiler 可以可视化并发任务的执行时间线，帮助识别性能瓶颈、死锁或活锁。
  • 日志记录：详细的、带有时间戳和任务标识符的日志记录可以帮助你追踪事件发生的顺序和不同任务之间的交互。
  • 最小化可复现性：当遇到并发 bug 时，尝试将其隔离到最小的可复现代码块，这将大大简化调试过程。
  • 使用 Actor：尽可能地使用 Actor 来保护共享的可变状态。它们强制了数据访问的隔离，使得数据竞争更难发生，也更容易被发现。
  • Sendable 检查：利用编译器对 Sendable 协议的检查，确保数据在并发域之间安全传递。编译器的警告和错误是发现并发问题的第一道防线。

有效的错误处理和系统的调试方法是掌握 Swift Concurrency 不可或缺的一部分。通过结构化并发，Swift 极大地简化了这些复杂性，让开发者能够更有信心构建高性能和高可靠性的并发应用程序。

8. 最佳实践与高级话题

掌握了 Swift Concurrency 的核心概念后，了解一些最佳实践和高级技巧能帮助你写出更高效、更可靠、更易于维护的并发代码。

8.1 避免过度并发

虽然并发可以提高应用程序的响应速度和吞吐量，但过度并发反而可能适得其反。
* 资源争夺：创建过多的任务会导致系统花费大量时间在任务切换和调度上，而不是执行实际工作。
* 内存消耗：每个任务都需要一定的内存开销。过多的任务可能耗尽内存，导致性能下降或崩溃。
* 复杂性增加：任务越多，逻辑越复杂，数据竞争和死锁的风险越高。

实践：
* 限制并发数量：使用 TaskGroup 时，可以手动控制同时活跃的子任务数量。
* 利用系统调度：让 Swift Concurrency 运行时自动管理任务的调度，而不是手动创建和管理大量线程。

8.2 任务的粒度选择

选择合适的任务粒度对于并发性能至关重要。
* 过小的粒度：如果每个任务执行的操作过于简单，任务切换的开销可能大于任务本身执行的价值。
* 过大的粒度：如果任务执行时间过长，可能导致 UI 阻塞或响应不及时。

实践：
* 平衡：理想的任务粒度是足够大，以至于任务切换的开销相对较小；同时又足够小，以允许有效的并行化和响应性。
* 分析：使用 Instruments 等工具分析你的应用程序，识别热点和瓶颈，根据实际性能数据来调整任务粒度。

8.3 避免死锁

死锁是并发编程中最难解决的问题之一，它发生在两个或多个任务相互等待对方释放资源时。在 Swift Concurrency 中，Actor 的重入机制在一定程度上缓解了死锁的风险，但并非完全消除。

实践：
* 避免循环依赖：如果 Actor A 需要调用 Actor B 的方法，而 Actor B 又需要调用 Actor A 的方法，这很容易导致死锁。考虑重新设计你的 Actor 结构或引入中间协调者。
* 明确资源获取顺序：如果任务需要获取多个资源，确保它们以相同的顺序获取，可以避免某些类型的死锁。
* 超时机制：为异步操作设置超时，防止任务无限期等待。

8.4 性能考量

  • 使用 async let 和 TaskGroup 进行并行化：当有多个独立的操作需要执行时，async let 或 TaskGroup 是最佳选择，它们能充分利用多核处理器。
  • 减少 await 暂停点：虽然 await 不阻塞线程，但每次 await 都会产生上下文切换的开销。尝试将紧密相关的同步操作组合在一起，减少不必要的 await。
  • 数据结构选择：选择适合并发访问的数据结构。如果需要共享可变数据，考虑使用 Actor 或线程安全的数据结构。
  • 避免不必要的内存拷贝：值类型在并发传递时会进行拷贝，如果数据量大，可能会产生性能开销。适时使用引用类型（如 Actor）或共享不可变数据。

8.5 与现有代码的集成 (Migration)

在现有项目中引入 Swift Concurrency 时，通常需要逐步迁移。
* 桥接传统回调 (withCheckedContinuation)：这是将现有基于回调的 API 适配到 async/await 世界的有效方式。
* GCD 与 Concurrency 混合使用：在某些情况下，可能需要同时使用 GCD 和 Swift Concurrency。
* 从 GCD 调度到 Concurrency：你可以使用 Task { ... } 在 GCD 队列中启动一个并发任务。
* 从 Concurrency 调度到 GCD：可以在 async 函数中使用 await DispatchQueue.main.async { ... } 来在主队列上执行代码。
* 注意隔离：当混合使用时，特别要注意 Actor 的隔离性。如果一个 Actor 方法内部需要调用 GCD 上的代码，并等待其结果，你需要小心处理上下文切换，确保 Actor 的状态在切换过程中不会被其他任务意外修改。

8.6 深入理解 Actor Reentrancy

如前所述，Actor 的重入机制可能导致竞态条件。
* 重新验证状态：在 await 之后，如果你的逻辑依赖于 Actor 内部的某个状态，你需要再次检查该状态是否仍然有效。
* 细粒度 Actor：将一个大型 Actor 分解为多个职责单一的小型 Actor，每个 Actor 负责管理更少的状态，可以降低重入引入问题的复杂性。

8.7 全局 Actor 的使用场景

除了 MainActor，你还可以定义自己的全局 Actor，用于需要全局单例且需要并发保护的资源。
“`swift
actor GlobalDataManager {
static let shared = GlobalDataManager() // 单例

private var cache: [String: Data] = [:]

func fetchData(key: String) async -> Data? {
    if let data = cache[key] {
        return data
    }
    // 模拟网络请求
    await Task.sleep(nanoseconds: 1 * 1_000_000_000)
    let newData = Data("Some data for \(key)".utf8)
    cache[key] = newData
    return newData
}

}

func useGlobalActor() async {
let data = await GlobalDataManager.shared.fetchData(key: “profile”)
print(“全局数据管理器获取到数据: (String(describing: data))”)
}

// 调用 (在 Playground 或 App 启动时执行)
// Task { await useGlobalActor() }
“`

遵循这些最佳实践，并持续学习和实践 Swift Concurrency，将帮助你更自信地构建高性能、高可靠的现代 Swift 应用程序。

9. 总结

Swift Concurrency 的引入标志着 Swift 语言在异步和并行编程领域迈出了革命性的一步。通过 async/await 语法、Task、Actor 和 Sendable 等核心特性，它为开发者提供了一套强大、安全且易于理解的工具集，彻底改变了我们编写并发代码的方式。

核心优势回顾：

  • 代码可读性与维护性：async/await 将异步代码扁平化，使其像同步代码一样直观，消除了传统回调地狱的复杂性。
  • 并发安全：Actor 模型通过隔离和串行执行保证了共享可变状态的安全性，而 Sendable 协议则在编译时提供了数据安全传递的保障，从语言层面有效预防了数据竞争。
  • 结构化并发：TaskGroup 和 async let 带来了任务生命周期的自动管理、错误传播和取消传播机制，大大提升了并发操作的可靠性。
  • 高效且现代化：新的并发运行时能够更智能地调度任务，优化资源利用，使得应用程序在多核处理器上表现出更好的性能。
  • 与现有代码的无缝集成：withCheckedContinuation 等工具允许开发者逐步将现有代码库迁移到新的并发模型中。

展望未来发展：

Swift Concurrency 仍在不断发展和完善中。随着语言和工具链的迭代，我们可以期待更强大的调试工具、更优化的运行时性能，以及更多高级的并发原语。它将持续简化并发编程的复杂性，使开发者能够更加专注于构建功能丰富、响应迅速且高度可靠的应用程序。

对于任何现代 Swift 开发者而言，深入理解并熟练运用 Swift Concurrency 已经成为一项不可或缺的技能。它不仅提升了开发效率，更从根本上改变了 Swift 应用程序的质量和稳定性。现在正是踏上 Swift Concurrency 学习之路的最佳时机，相信它将为你的项目带来显著的改进。

附录

滚动至顶部