Swift中使用Async Task Groups时如何跳过重复项并更新UI？

一、Task Group中处理去重与Optional返回值问题 #

你遇到的withTaskGroup(of: SWDAApplicationItem?)报错，大概率是对Task Group结果收集的逻辑处理有误。这里提供两种可行的实现思路：

方案1：先收集有效实例，再统一去重 #

这种方式更简洁，还能避免并发场景下的线程安全问题：

func loadApplicationItems(from bundleIDs: [String]) async -> [SWDAApplicationItem] {
    await withTaskGroup(of: SWDAApplicationItem?.self) { group in
        // 遍历bundleID，提交初始化任务到Task Group
        for bundleID in bundleIDs {
            group.addTask {
                // 初始化失败则返回nil
                guard let item = SWDAApplicationItem(bundleID: bundleID) else {
                    return nil
                }
                return item
            }
        }
        
        // 收集所有非nil的实例
        var allItems: [SWDAApplicationItem] = []
        for await result in group {
            if let item = result {
                allItems.append(item)
            }
        }
        
        // 按appBundleID去重
        var seenBundleIDs = Set<String>()
        let uniqueItems = allItems.filter { item in
            guard !seenBundleIDs.contains(item.appBundleID) else {
                return false
            }
            seenBundleIDs.insert(item.appBundleID)
            return true
        }
        
        return uniqueItems
    }
}

先把所有有效实例收集完成，再通过Set记录已出现的bundleID来过滤重复项，完全避开了并发任务同时修改同一数组的风险。

方案2：实时线程安全检查并添加 #

如果需要在任务执行过程中实时去重（比如避免创建重复实例），要保证对存储集合的访问是线程安全的：

func loadApplicationItems(from bundleIDs: [String]) async -> [SWDAApplicationItem] {
    var uniqueItems: [SWDAApplicationItem] = []
    let lock = NSLock()
    var seenBundleIDs = Set<String>()
    
    await withTaskGroup(of: SWDAApplicationItem?.self) { group in
        for bundleID in bundleIDs {
            group.addTask {
                // 加锁检查是否已存在该bundleID
                guard !lock.withLock({ seenBundleIDs.contains(bundleID) }) else {
                    return nil
                }
                
                guard let item = SWDAApplicationItem(bundleID: bundleID) else {
                    return nil
                }
                
                // 加锁更新集合，避免竞态条件
                lock.withLock {
                    if !seenBundleIDs.contains(item.appBundleID) {
                        seenBundleIDs.insert(item.appBundleID)
                        uniqueItems.append(item)
                    }
                }
                
                return item
            }
        }
        
        // 等待所有任务执行完毕
        _ = await group.reduce(into: ()) { _, _ in }
    }
    
    return uniqueItems
}

这里用NSLock保护对seenBundleIDs和uniqueItems的访问，确保并发任务不会同时修改这些数据结构。

关于TaskGroup.next()和for await的选择：for await result in group是遍历所有任务结果的简洁方式，next()适合需要手动控制遍历流程的场景（比如提前终止），日常用前者就足够。

二、后台处理时正确更新UI #

是的，两种方式都能保证UI操作在主线程执行：

方式1：给UI更新函数加@MainActor标记 #

@MainActor
func updateUI(with items: [SWDAApplicationItem]) {
    self.applicationItems = items
    self.tableView.reloadData()
}

// 在任务中直接调用
Task {
    let items = await loadApplicationItems(from: bundleIDs)
    updateUI(with: items)
}

方式2：用MainActor.run包裹UI更新逻辑 #

func loadAndUpdateUI() async {
    let items = await loadApplicationItems(from: bundleIDs)
    await MainActor.run {
        self.applicationItems = items
        self.tableView.reloadData()
    }
}

内容的提问来源于stack exchange，提问作者Gregorio Litenstein