swift中的await/async

1.定义一个异步的方法

使用async关键字，表示这是一个异步的方法。这里用withCheckedContinuation配合DispatchQueue.main.asyncAfter模拟一个网络请求。

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)
        })
    }
}

2.在异步方法中调用异步方法

使用await关键字

func asyncTestMethod() async {
    CWLog("111")
    let result = await testMethod(value: 2)
    CWLog("222")
}

// 1: 111
// 2: 4
// 3: 222

3.在同步方法中调用异步方法

使用Task

override func viewDidLoad() {
    super.viewDidLoad()
    Task {
      await testMethod()
    }
}

4.并发执行多个异步方法，并最后统一处理结果

类似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)
            })
        }
    }
}

---

部分场景也可以使用async + let来实现。

import UIKit

class ViewController: UIViewController {
    
    override func viewDidLoad() {
        super.viewDidLoad()
        Task {
            CWLog("begin")
            async let name = getName()
            async let age = getAge()
            async let hobby = getHobby()
            CWLog(await age)
            CWLog(await hobby)
            CWLog(await name)
        }
    }
    
    func getName() async -> String {
        return await withUnsafeContinuation { continuation in
            DispatchQueue.main.asyncAfter(deadline: .now() + 1, execute: {
                CWLog("getName")
                continuation.resume(returning: "chen wang")
            })
        }
    }
    
    func getAge() async -> Int {
        return await withUnsafeContinuation { continuation in
            DispatchQueue.main.asyncAfter(deadline: .now() + 3, execute: {
                CWLog("getAge")
                continuation.resume(returning: 18)
            })
        }
    }
    
    func getHobby() async -> [String] {
        return await withUnsafeContinuation { continuation in
            DispatchQueue.main.asyncAfter(deadline: .now() + 2, execute: {
                CWLog("getHobby")
                continuation.resume(returning: ["game", "book"])
            })
        }
    }
}

上面代码中，getName、getAge、getHobby这个三方法也是并行的，不分先后顺序。

async let name = getName()
async let age = getAge()
async let hobby = getHobby()