Task是 Swift 5.5 以后结构化并发模型的实现，async/await 以结构化的方式实现了代码的定义和调用。Task和async/await的配合，避免了异步结构在原oc中多层嵌套回调的形式，代码看起来会更加简洁清晰。
1. Task
Task 允许在同步方法中创建并发的异步任务执行的单元结构：
// Task任务在创建后会立即运行，不需要显式启动
class ViewController: UIViewController {
override func viewDidLoad() {
super.viewDidLoad()
Task {
print("执行任务")
}
}
}
2. async/await
async 表明一个方法以异步的方式执行：
// 用 async 直接进行异步加载图片
func fetchImages() async -> UIImage {
let data = try! Data(contentsOf: URL.init(string: "https://img1.baidu.com/it/u=413643897,2296924942&fm=253&fmt=auto&app=138&f=JPEG?w=800&h=500")!)
return UIImage(data: data, scale: 1)!
}
await 用于调用一个异步方法，在当前线程中会等到被 await 修饰的方法执行完成后，再执行其后面的代码：
let image = await fetchImages()
print("拿到image去做一些额外的处理")
注：用await来调用swift异步代码，会卡住当前线程使其处于等待状态；而使用oc的回调方式，一般会直接新起一个异步线程，同时执行block中的任务；我们称前者为结构性并发。
3. Task 和 async/wait 使用场景
- Task 修饰
在一个同步环境中试图用 await 直接调用 async 的异步方法，会报错。现有的同步环境是不支持直接执行结构性并发代码。这时就需要使用 Task 修饰：
class ViewController: UIViewController {
override func viewDidLoad() {
super.viewDidLoad()
Task {
let image = await fetchImages()
let newImage = await ClipImages(image: image)
}
}
}
- async-let 修饰
如果要调用异步方法并允许它异步执行，可以用async-let进行修饰，形式如下：
async let firstPhoto = downloadPhoto(named: photoNames[0])
async let secondPhoto = downloadPhoto(named: photoNames[1])
async let thirdPhoto = downloadPhoto(named: photoNames[2])
let photos = await [firstPhoto, secondPhoto, thirdPhoto]
show(photos)
当代码中下一行依赖函数结果时，使用 await 会使工作顺序执行；使用 async-let 调用异步函数可以简化多个异步任务的调用。
- 模拟一个网络请求。
func testMethod(value: Int) async -> Int {
return await withCheckedContinuation { continuation in
DispatchQueue.main.asyncAfter(deadline: .now() + 1, execute: {
let result = value * 2
CWLog(result)
continuation.resume(returning: result)
})
}
}
- 在异步方法中调用异步方法
// 使用await关键字
func asyncTestMethod() async {
CWLog("111")
let result = await testMethod(value: 2)
CWLog("222")
}
// 1: 111
// 2: 4
// 3: 222
- 在同步方法中调用异步方法
// 使用Task
override func viewDidLoad() {
super.viewDidLoad()
Task {
await testMethod()
}
}
- 并发执行多个异步方法，并最后统一处理结果
// 类似GCD中的dispatch_group, 采用TaskGroup来实现
override func viewDidLoad() {
super.viewDidLoad()
CWLog("111")
Task(priority: .background) {
CWLog("222")
let result = await withTaskGroup(of: Int.self, returning: [Int].self) { [weak self] group in
guard let `self` = self else {return []}
// 模拟4个任务
for i in 1...4 {
group.addTask {
// 这里处理添加单个的task
return await self.testMethod(value: i)
}
}
var arr: [Int] = []
// 这里统一处理结果
for await result in group {
arr.append(result)
}
// 返回结果
return arr
}
CWLog(result)
}
CWLog("333")
}
在调用withTaskGroup时：
第一个参数：每个异步任务返回的数据类型；
第二个参数：所有异步任务执行完成后，汇总之后的数据类型；
第三个参数: 闭包，具体业务逻辑。
注意：汇总处理的（for await...in...）和addTask时的（for...in...）顺序是不一定对的上的，最终返回的结果是无序的。
如果想要返回的结果是有序的，可是采用多个Task的方式来实现：
import UIKit
class ViewController: UIViewController {
override func viewDidLoad() {
super.viewDidLoad()
Task { [weak self] in
guard let `self` = self else {return}
let tasks = [1 ,2 ,3 ,4].map { item in
return Task {
return await self.testMethod(value: item)
}
}
let result = await withTaskCancellationHandler {
var values: [Int] = []
for task in tasks {
values.append(await task.value)
}
return values
} onCancel: {
tasks.forEach { $0.cancel() }
}
CWLog(result)
}
}
func testMethod(value: Int) async -> Int {
return await withCheckedContinuation { continuation in
DispatchQueue.main.asyncAfter(deadline: .now() + 1, execute: {
let result = value * 2
CWLog(result)
continuation.resume(returning: result)
})
}
}
}
