GCD迁移到async/await

Grand Central Dispatch（GCD）长期以来是Swift和Objective-C中处理并发的主要工具，通过队列和闭包实现了强大的异步编程能力。然而，Swift 5.5引入的async/await提供了一种更直观、更现代的并发模型，显著提升了代码可读性和错误处理能力。本节将介绍如何将现有GCD代码迁移到async/await，分析迁移步骤及其带来的改进，帮助你将遗留代码升级为现代并发风格。

为什么迁移到async/await？

GCD虽然功能强大，但存在一些局限：

  • 嵌套闭包：复杂任务导致“回调地狱”，代码难以阅读。
  • 错误处理分散：需在每个闭包中单独处理错误。
  • 手动线程切换：主线程更新UI需显式调用DispatchQueue.main.async。

async/await的优点：

  • 线性代码：消除嵌套，逻辑更直观。
  • 统一错误处理：通过try/catch集中管理异常。
  • 自动线程管理：配合@MainActor，简化主线程切换。

示例（GCD代码）：

func fetchData(completion: @escaping (Result<String, Error>) -> Void) {
    DispatchQueue.global().async {
        // 模拟网络请求
        sleep(1)
        let data = "GCD数据"
        DispatchQueue.main.async {
            completion(.success(data))
        }
    }
}

func updateUI() {
    fetchData { result in
        switch result {
        case .success(let data): label.text = data
        case .failure(let error): print("错误：\(error)")
        }
    }
}

迁移步骤

以下是将GCD代码迁移到async/await的通用步骤：

1. 将闭包函数转为异步函数

将依赖闭包的函数改为返回值的async函数，支持错误抛出：

func fetchData() async throws -> String {
    try await Task.sleep(nanoseconds: 1_000_000_000) // 模拟延迟
    return "Async数据"
}
  • 移除completion闭包，使用async throws返回结果。

2. 替换DispatchQueue调用

将DispatchQueue.global().async替换为Task或直接调用：

// GCD
DispatchQueue.global().async {
    let data = performWork()
    DispatchQueue.main.async {
        label.text = data
    }
}

// Async/Await
Task {
    let data = await performWork()
    await MainActor.run { label.text = data }
}
  • Task替代后台队列，@MainActor替代主队列。

3. 重构调用逻辑

将嵌套闭包转为线性流程：

// GCD
func fetchAndUpdate() {
    fetchData { result in
        switch result {
        case .success(let data):
            processData(data) { processed in
                DispatchQueue.main.async {
                    label.text = processed
                }
            }
        case .failure(let error):
            print("错误：\(error)")
        }
    }
}

// Async/Await
func fetchAndUpdate() async throws {
    let data = try await fetchData()
    let processed = await processData(data)
    await MainActor.run { label.text = processed }
}

func processData(_ data: String) async -> String {
    try? await Task.sleep(nanoseconds: 500_000_000)
    return "处理：\(data)"
}
  • 线性代码更清晰，错误集中处理。

4. 集成到UI

在视图控制器中使用异步函数：

@MainActor
class ViewController: UIViewController {
    @IBOutlet weak var label: UILabel!
    
    override func viewDidLoad() {
        super.viewDidLoad()
        Task { try await fetchAndUpdate() }
    }
}
  • @MainActor确保UI更新安全。

迁移示例：批量任务

以下是一个GCD批量任务的迁移案例：

GCD实现

func fetchBatchData(completion: @escaping ([String]) -> Void) {
    let queue = DispatchQueue.global()
    var results: [String] = []
    let group = DispatchGroup()
    
    for i in 1...3 {
        group.enter()
        queue.async {
            sleep(1)
            results.append("数据\(i)")
            group.leave()
        }
    }
    
    group.notify(queue: .main) {
        completion(results)
    }
}

func updateBatchUI() {
    fetchBatchData { data in
        label.text = data.joined(separator: ", ")
    }
}

Async/Await实现

func fetchBatchData() async -> [String] {
    await withTaskGroup(of: String.self) { group in
        for i in 1...3 {
            group.addTask {
                try? await Task.sleep(nanoseconds: 1_000_000_000)
                return "数据\(i)"
            }
        }
        return await group.collectAll()
    }
}

@MainActor
func updateBatchUI() async {
    let data = await fetchBatchData()
    label.text = data.joined(separator: ", ")
}

extension AsyncTaskGroup { func collectAll() async -> [Element] { var results: [Element] = [] for await result in self { results.append(result) } return results } }


- **改进**：
  - `Task Group`替代`DispatchGroup`，更简洁。
  - 无需手动线程切换。
  - 结果收集更直观。

## 注意事项

1. **渐进迁移**  
   不必一次性迁移所有GCD代码，可逐步替换关键路径，保持兼容：
   ```swift
   func fetchHybrid(completion: @escaping (String) -> Void) {
       Task {
           let data = try await fetchData()
           completion(data)
       }
   }

  1. 性能考量
    async/await底层仍依赖GCD，迁移不会显著影响性能，但需注意频繁await的切换开销。

  2. 错误处理
    充分利用throws替代Result：

    // GCD
completion(.failure(error))

// Async/Await
throw error

  3. 测试验证
    迁移后运行Thread Sanitizer，确保无新竞争。

优势总结

  • 可读性：线性代码替代嵌套闭包。
  • 安全性：@MainActor确保UI线程安全。
  • 简洁性：减少线程切换和错误处理代码。

小结

将GCD迁移到async/await是Swift并发现代化的重要一步。本节通过步骤和示例展示了迁移过程，从单任务到批量任务，体现了新模型的优雅性。掌握这些技巧，你将能将遗留代码升级为更简洁、安全的实现。下一节将探讨与Objective-C代码的互操作，进一步扩展你的迁移能力。

内容说明

  • 结构：从背景到步骤，再到示例、注意事项和总结。
  • 代码：包含单任务和批量任务迁移示例，突出实用性。
  • 语气：实践性且基础性，适合新章节开篇。
  • 衔接：承接第十二章（竞争调试），预告后续（Objective-C互操作）。
Last Updated::