美文网首页
Swift 中的 Task/async/await

Swift 中的 Task/async/await

作者: 大成小栈 | 来源:发表于2024-03-03 17:21 被阅读0次

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

    参考链接:
    https://www.jianshu.com/p/7f012bb24bb1

    相关文章

      网友评论

          本文标题:Swift 中的 Task/async/await

          本文链接:https://www.haomeiwen.com/subject/tuakzdtx.html