掌握 Swift 中的 DispatchGroup：多任务协调利器

在 Swift 开发中，处理多个并行异步任务并在它们全部完成后执行操作是一个常见需求。尽管 Swift 5.5 引入了 async/await 并发系统，DispatchGroup 仍然是一个强大且常用的工具，特别是在处理现有的基于回调的 API 时。本文将详细介绍 DispatchGroup 的用法、最佳实践以及在实际开发中的应用，帮助你快速掌握这一工具。

1. DispatchGroup 基础概念

DispatchGroup 是 Swift 中 Grand Central Dispatch (GCD) 提供的一个同步原语，用于将多个异步任务组织成一个组，并在所有任务完成后收到通知。它的核心思想是创建一个"计数器"，每开始一个任务就增加计数，每完成一个任务就减少计数，当计数归零时触发通知。

创建与初始化

swift

let group = DispatchGroup()

这行代码做了什么？

let：Swift 的常量声明关键字，表示 group 是一个不可变引用。
group：变量名，可以根据需要自定义命名。
DispatchGroup()：调用 DispatchGroup 的构造函数，创建一个新的组实例，初始计数为零。

与其他并发工具的对比

工具	主要用途	优势
`DispatchGroup`	等待多个异步任务完成	简单、轻量、适用于回调式API
`DispatchSemaphore`	限制并发访问数量	可控制并发数量
`async/await` (iOS 15+)	结构化并发	代码更清晰，自动传播错误
`Task`	现代并发任务单元	支持取消，集成Swift并发系统

尽管有了现代并发API，DispatchGroup在处理第三方库或系统API时仍然非常有用，因为这些API可能仍然使用基于回调的模式。

2. DispatchGroup 的使用方法

基本用法：enter/leave 模式

以下是一个简单的例子，展示如何使用 DispatchGroup 协调异步任务：

swift

let group = DispatchGroup()

// 任务 1
group.enter()  // 计数器 +1
DispatchQueue.global().async {
    print("任务 1 开始")
    sleep(1) // 模拟异步操作
    print("任务 1 完成")
    group.leave()  // 计数器 -1
}

// 任务 2
group.enter()  // 计数器 +1
DispatchQueue.global().async {
    print("任务 2 开始")
    sleep(2) // 模拟异步操作
    print("任务 2 完成")
    group.leave()  // 计数器 -1
}

// 所有任务完成后执行（计数器归零时）
group.notify(queue: .main) {
    print("所有任务完成！")
}

运行结果：

任务 1 开始
任务 2 开始
任务 1 完成
任务 2 完成
所有任务完成！

自动管理计数的方法：async(group:)

除了手动enter/leave外，GCD还提供了自动管理计数的方法：

swift

let group = DispatchGroup()
let queue = DispatchQueue.global()

// 自动管理enter/leave
queue.async(group: group) {
    print("任务 1 执行中")
    sleep(1)
}

queue.async(group: group) {
    print("任务 2 执行中")
    sleep(2)
}

group.notify(queue: .main) {
    print("所有任务完成！")
}

这种方法更安全，因为它保证了enter/leave的平衡，避免了遗漏。

同步等待

有时你可能需要阻塞当前线程，直到所有任务完成：

swift

let group = DispatchGroup()
// 添加任务...

// 等待最多5秒
let result = group.wait(timeout: .now() + 5)
switch result {
case .success:
    print("所有任务成功完成")
case .timedOut:
    print("超时！有任务未完成")
}

⚠️ 警告：避免在主线程上使用wait方法，否则可能导致UI冻结。

关键点

成对调用：enter() 和 leave() 必须成对出现，否则组无法完成。
线程安全：DispatchGroup 是线程安全的，所有方法都可在多线程环境中安全调用。
不可变性：group引用本身是不可变的，但其内部计数状态会变化。
计数管理：尽可能使用async(group:)方法自动管理计数，减少错误风险。

3. 实际应用场景

场景一：聚合多个网络请求结果

在开发中，常常需要同时发起多个网络请求，并在所有请求完成后处理汇总数据：

swift

let group = DispatchGroup()
var userData: UserData?
var userPosts: [Post]?
var userFollowers: [User]?
var errors: [Error] = []

group.enter()
networkService.fetchUserProfile { result in
    switch result {
    case .success(let data):
        userData = data
    case .failure(let error):
        errors.append(error)
    }
    group.leave()
}

group.enter()
networkService.fetchUserPosts { result in
    switch result {
    case .success(let posts):
        userPosts = posts
    case .failure(let error):
        errors.append(error)
    }
    group.leave()
}

group.enter()
networkService.fetchUserFollowers { result in
    switch result {
    case .success(let followers):
        userFollowers = followers
    case .failure(let error):
        errors.append(error)
    }
    group.leave()
}

group.notify(queue: .main) {
    if errors.isEmpty {
        // 所有请求成功，更新UI
        self.updateUI(userData: userData!, posts: userPosts!, followers: userFollowers!)
    } else {
        // 处理错误
        self.handleErrors(errors)
    }
}

场景二：批量资源处理与进度跟踪

当需要处理多个资源并跟踪整体进度时：

swift

func processBatchImages(_ images: [UIImage], completion: @escaping ([UIImage]) -> Void) {
    let group = DispatchGroup()
    let queue = DispatchQueue.global()
    let totalCount = images.count
    var processedCount = 0
    var processedImages = [UIImage?](repeating: nil, count: totalCount)
    
    for (index, image) in images.enumerated() {
        group.enter()
        queue.async {
            // 处理图像
            let processed = self.applyFilter(to: image)
            
            // 更新结果和进度
            DispatchQueue.main.async {
                processedImages[index] = processed
                processedCount += 1
                
                // 更新进度条
                let progress = Float(processedCount) / Float(totalCount)
                self.progressView.progress = progress
            }
            
            group.leave()
        }
    }
    
    group.notify(queue: .main) {
        // 过滤掉可能的nil值
        let finalImages = processedImages.compactMap { $0 }
        completion(finalImages)
    }
}

场景三：依赖任务链

有时我们需要等待一组任务完成后，再开始另一组任务：

swift

func performDataMigration() {
    let phase1Group = DispatchGroup()
    
    // 阶段1：准备工作
    phase1Group.enter()
    prepareDatabase { phase1Group.leave() }
    
    phase1Group.enter()
    downloadSchemaUpdates { phase1Group.leave() }
    
    // 阶段1完成后，开始阶段2
    phase1Group.notify(queue: .global()) {
        print("准备工作完成，开始数据迁移")
        
        let phase2Group = DispatchGroup()
        
        phase2Group.enter()
        migrateUserData { phase2Group.leave() }
        
        phase2Group.enter()
        migrateSettings { phase2Group.leave() }
        
        // 所有迁移完成
        phase2Group.notify(queue: .main) {
            print("数据迁移完成")
            self.showCompletionAlert()
        }
    }
}

4. 常见错误与最佳实践

常见错误

未配对的enter/leave调用

swift

// ❌ 错误示例
group.enter()
networkCall { data in
    if data != nil {
        processData(data!)
        group.leave()  // 只有成功才调用leave
    }
    // 失败时未调用leave
}

swift

// ✅ 正确处理
group.enter()
networkCall { data in
    defer { group.leave() }  // 保证无论如何都会调用
    
    if let data = data {
        processData(data)
    }
}

忘记在主队列更新UI

swift

// ❌ 错误示例
group.notify(queue: .global()) {  // 在后台队列
    self.label.text = "完成"  // 更新UI必须在主线程
}

swift

// ✅ 正确处理
group.notify(queue: .main) {
    self.label.text = "完成"
}

在主线程等待

swift

// ❌ 错误示例 - 可能导致UI冻结
@IBAction func onButtonTap() {
    let group = DispatchGroup()
    // 添加任务...
    group.wait()  // 在主线程阻塞
}

最佳实践

使用defer确保leave被调用

swift

group.enter()
someAsyncTask { result in
    defer { group.leave() }
    // 安全处理结果...
}

考虑使用async(group:)替代手动enter/leave

swift

let queue = DispatchQueue.global()
queue.async(group: group) {
    // 任务自动计数管理
}

结合超时处理

swift

let result = group.wait(timeout: .now() + 5)
if result == .timedOut {
    // 实现超时后的清理和错误处理
}

使用串行队列保护共享数据

swift

let group = DispatchGroup()
let resultsQueue = DispatchQueue(label: "com.myapp.results") // 串行队列
var results = [String: Any]() // 共享数据

group.enter()
doAsyncWork { data in
    resultsQueue.async {
        results["key"] = data // 安全访问共享数据
        group.leave()
    }
}

5. 与现代Swift并发的比较

Swift 5.5及更高版本引入了async/await模式，下面是同一功能的对比实现：

DispatchGroup实现（传统）

swift

func fetchData() {
    let group = DispatchGroup()
    var userResult: User?
    var postsResult: [Post]?
    
    group.enter()
    userAPI.fetchUser { user in
        userResult = user
        group.leave()
    }
    
    group.enter()
    postAPI.fetchPosts { posts in
        postsResult = posts
        group.leave()
    }
    
    group.notify(queue: .main) {
        self.update(user: userResult, posts: postsResult)
    }
}

Swift现代并发实现

swift

// iOS 15+
func fetchData() async throws {
    async let user = userAPI.fetchUser()
    async let posts = postAPI.fetchPosts()
    
    let (fetchedUser, fetchedPosts) = try await (user, posts)
    await MainActor.run {
        self.update(user: fetchedUser, posts: fetchedPosts)
    }
}

尽管现代并发模型更为简洁、可读性更强，但DispatchGroup在以下场景中仍有价值：

处理基于回调的旧API
需要支持iOS 15以下的系统
对异步操作进行精细控制

6. 总结

DispatchGroup 是Swift中一个强大的同步原语，在进行多任务协调时非常有用。关键点包括：

它通过计数器机制跟踪任务完成情况
提供了手动(enter/leave)和自动(async(group:))两种计数管理方式
可通过notify异步接收完成通知，或通过wait同步等待完成
在处理网络请求、批量资源处理等场景中有广泛应用

随着Swift并发系统的发展，DispatchGroup与现代async/await可以结合使用，灵活应对不同的开发场景。无论你是使用传统GCD还是现代并发系统，理解DispatchGroup的工作原理都有助于编写更高效、更可靠的异步代码。

掌握 Swift 中的 DispatchGroup：多任务协调利器 ​

1. DispatchGroup 基础概念 ​

创建与初始化 ​

与其他并发工具的对比 ​

2. DispatchGroup 的使用方法 ​

基本用法：enter/leave 模式 ​

自动管理计数的方法：async(group:) ​

同步等待 ​

关键点 ​

3. 实际应用场景 ​

场景一：聚合多个网络请求结果 ​

场景二：批量资源处理与进度跟踪 ​

场景三：依赖任务链 ​

4. 常见错误与最佳实践 ​

常见错误 ​

最佳实践 ​

5. 与现代Swift并发的比较 ​

DispatchGroup实现（传统） ​

Swift现代并发实现 ​

6. 总结 ​

掌握 Swift 中的 DispatchGroup：多任务协调利器

1. DispatchGroup 基础概念

创建与初始化

与其他并发工具的对比

2. DispatchGroup 的使用方法

基本用法：enter/leave 模式

自动管理计数的方法：async(group:)

同步等待

关键点

3. 实际应用场景

场景一：聚合多个网络请求结果

场景二：批量资源处理与进度跟踪

场景三：依赖任务链

4. 常见错误与最佳实践

常见错误

最佳实践

5. 与现代Swift并发的比较

DispatchGroup实现（传统）

Swift现代并发实现

6. 总结