Swift concurrency 6 — TaskGroup的理解与使用

最新推荐文章于 2024-10-03 06:17:36 发布

技术拾光

最新推荐文章于 2024-10-03 06:17:36 发布

阅读量773

点赞数 22

分类专栏： Swift Concurrency 文章标签： swift ios TaskGroup

本文链接：https://blog.csdn.net/guoyongming925/article/details/141703047

版权

Swift Concurrency 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

在SwiftUI中，TaskGroup 是一种处理并发任务的工具，特别适用于需要并发执行多个独立任务并在它们都完成后进行进一步处理的场景。TaskGroup 提供了一种结构化并发的方法，使得并行任务的启动、管理和结果收集变得更加简便和安全。

一、TaskGroup的基本概念

TaskGroup 是 Swift 并发系统的一部分，它允许创建一组并行执行的任务，并在所有任务完成后进行后续操作。使用 TaskGroup 时，可以：

向组中添加多个并行任务。
等待所有任务完成，并收集它们的结果。
在任务执行过程中动态添加新的任务。

二、TaskGroup的基本用法

下面是使用 TaskGroup 的基本步骤：

创建一个 TaskGroup 实例。
向 TaskGroup 中添加任务。
等待所有任务完成，并收集任务结果。

创建 TaskGroup 的方法主要有两种：withTaskGroup 和 withThrowingTaskGroup

withTaskGroup

withTaskGroup 是用于并行执行一组任务的结构。它允许我们启动多个子任务，并在所有子任务完成后汇总结果。它的主要特点是它不会抛出错误。

class TaskGroupViewModel: ObservableObject {
    @Published var images: [UIImage] = []
    
    private var urlStrings = [
        "https://picsum.photos/300",
        "https://picsum.photos/300",
        "https://picsum.photos/300",
        "https://picsum.photos/300",
        "https://picsum.photos/300",
        "https://picsum.photos/300",
        "https://picsum.photos/300",
        "https://picsum.photos/300",
        "https://picsum.photos/300",
        "https://picsum.photos/300",
        "https://picsum.photos/300",
        "https://picsum.photos/300",
        "https://picsum.photos/300",
        "https://picsum.photos/300",
        "https://picsum.photos/300",
        "https://picsum.photos/300",
        "https://picsum.photos/300"
    ]
    
    func fetchImageWithTaskGroup() async {
        await withTaskGroup(of: UIImage?.self) { group in
            for urlString in urlStrings {
                group.addTask {
                    try? await self.fetchImage(urlString: urlString)
                }
            }
            
            for await image in group {
                if let image {
                    images.append(image)
                }
            }
        }
    }
    
    private func fetchImage(urlString: String) async throws -> UIImage {
        guard let url = URL(string: urlString) else {
            throw URLError(.badURL)
        }
        
        do {
            let (data, _) = try await URLSession.shared.data(from: url)
            if let image = UIImage(data: data) {
                return image
            } else {
                throw URLError(.badURL)
            }
        } catch {
            throw error
        }
    }
}

在上面TaskGroupViewModel中，我们定义了一组图片的url，定义了一个私有方法fetchImage去请求图片。最后在fetchImageWithTaskGroup方法中通过withTaskGroup创建TaskGroup，然后发出所有异步请求。

withTaskGroup 创建一个任务组，用于并行执行多个异步操作。
group.addTask 添加子任务到任务组。
for await image in group 循环等待所有子任务的完成，并收集它们的结果。这里需要加await。
最终返回的是所有子任务的结果的数组。
因为在fetchImage方法有可能抛出异常，所以在调用的地方使用了try?，如果抛出异常就忽略，因此该方法的返回值有可能是UIImage，也有可能是nil，所有withTaskGroup的初始化中传入的UIImage类型为可选类型UIImage?.self

UI调用的地方也比较简单，采用.task修饰符即可。

@StateObject private var viewModel = TaskGroupViewModel()
let columns = [GridItem(.flexible()), GridItem(.flexible())]

var body: some View {
    ScrollView {
        LazyVGrid(columns: columns) {
            ForEach(viewModel.images, id: \.self) { image in
                Image(uiImage: image)
                    .resizable()
                    .scaledToFit()
                    .frame(height: 150)
            }
        }
    }
    .task {
        await viewModel.fetchImageWithTaskGroup()
    }
}

withThrowingTaskGroup

withThrowingTaskGroup 和 withTaskGroup 类似，但不同的是，它能够处理子任务抛出的错误。如果任何一个子任务抛出错误，整个任务组的执行会立即停止，并将该错误抛出。

func fetchImageWithThrowingTaskGroup() async throws {
    try await withThrowingTaskGroup(of: UIImage?.self) { group in
        for urlString in urlStrings {
            group.addTask {
                do {
                    return try await self.fetchImage(urlString: urlString)
                } catch {
                    throw URLError(.badURL)
                }
            }
        }
        
        for try await image in group {
            if let image {
                images.append(image)
            }
        }
    }
}

withThrowingTaskGroup 和 withTaskGroup 的用法类似，但它的任务组内的任务可以抛出错误。
group.addTask 添加的子任务可能会抛出错误，因此需要用 try await 来调用，并且加上了return，否则报错，在fetchImageWithTaskGroup方法的addTask闭包中也可以加return。
for try await image in group 需要用 try await 来处理子任务的结果，确保在遇到错误时能够捕获，因为在addTask闭包中可能会抛出异常。

在调用的地方：

.task {
    do {
       try await viewModel.fetchImageWithThrowingTaskGroup()
    } catch {
        print(error.localizedDescription)
    }
}

这里还要说一下，不管是fetchImageWithTaskGroup还是fetchImageWithThrowingTaskGroup方法，都是没有返回值的，因为他们是在ViewModel中定义的，在方法内部直接就是属性赋值了，然后触发UI的刷新，如果这两个方法是在其他的网络层里面，而ViewModel调用网络层中的这个方法，下面看一下：

class TaskGroupDataProvider {
    private var urlStrings = [
        "https://picsum.photos/300",
        ......
        "https://picsum.photos/300"
    ]
    
    func fetchImageWithTaskGroup() async -> [UIImage] {
        return await withTaskGroup(of: UIImage?.self) { group in
            var images: [UIImage] = []
            images.reserveCapacity(urlStrings.count)
            
            for urlString in urlStrings {
                group.addTask {
                    try? await self.fetchImage(urlString: urlString)
                }
            }
            
            for await image in group {
                if let image {
                    images.append(image)
                }
            }
            return images
        }
    }
    
    func fetchImageWithThrowingTaskGroup() async throws -> [UIImage] {
        return try await withThrowingTaskGroup(of: UIImage?.self) { group in
            var images: [UIImage] = []
            images.reserveCapacity(urlStrings.count)
            
            for urlString in urlStrings {
                group.addTask {
                    do {
                        return try await self.fetchImage(urlString: urlString)
                    } catch {
                        throw URLError(.badURL)
                    }
                }
            }
            
            for try await image in group {
                if let image {
                    images.append(image)
                }
            }
            return images
        }
    }
    
    private func fetchImage(urlString: String) async throws -> UIImage {
        guard let url = URL(string: urlString) else {
            throw URLError(.badURL)
        }
        
        do {
            let (data, _) = try await URLSession.shared.data(from: url)
            if let image = UIImage(data: data) {
                return image
            } else {
                throw URLError(.badURL)
            }
        } catch {
            throw error
        }
    }
}

上面代码中我们将fetchImageWithTaskGroup还是fetchImageWithThrowingTaskGroup方法放到了一个TaskGroupDataProvider类中，TaskGroupDataProvider类作为网络层，单独处理数据。

我们给这两个方法都加了返回值[UIImage], 然后在这两个方法中调用withTaskGroup和withThrowingTaskGroup方法前都加了return，这样这withTaskGroup和withThrowingTaskGroup会将其内部的返回值return出去。
在这两个系统方法的最后处，我们也return我们自定义的UIImage数组。

特别说一下数组的reserveCapacity方法，一个性能优化的方法，如果已经知道了数组的空间大小，那么就一次性开辟出来，免得后续扩容带来的性能消耗。

最后在ViewModel中，重新定义两个方法去调用TaskGroupDataProvider类的对应方法。

class TaskGroupViewModel: ObservableObject {
    let dataProvider = TaskGroupDataProvider()
    
    @Published var images: [UIImage] = []
    
    func getImageWithTaskGroup() async {
        images = await dataProvider.fetchImageWithTaskGroup()
    }
    
    func getImageWithThrowingTaskGroup() async throws {
        images = try await dataProvider.fetchImageWithThrowingTaskGroup()
    }
}