记录swift新语法,task,async-await

因为最近经常遇到许多网络请求,需要满足一个条件,之后才能继续请求
在此举例:
{
登录中使用token
这个token,要作为后续某些网络请求的关键,而token也存在过期的问题,所以请求接口返回过期后,要重新请求token,再执行网络请求
!:传统写法

//1:GCD信号量控制
typealias NETBLock = ((Bool)->Void)
    var semaphore = DispatchSemaphore(value: 1)
    func textNET(){
        text(id: 1)
        DispatchQueue.main.asyncAfter(deadline: .now() + 0.3) {
            self.text(id: 2)
        }
        DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
            self.text(id: 3)
        }
    }
    func text(id:Int){
        DispatchQueue.global().async {[weak self] in
            print("👁[包含用户iD请求],开始请求,id\(id)")
            self?.semaphore.wait()
            print("👁[包含用户iD请求],等待执行,id\(id)")

            self?.regsiter { isRegsin in
                self?.semaphore.signal()
                print("👁[包含用户iD请求],结束等待,id\(id)")

                if isRegsin{
                    self?.load(block: { isSccuess in
                        if !isSccuess{
                            self?.semaphore.wait()
                            self?.login(block: { login in
                                self?.semaphore.signal()
                                if login{
                                    self?.text(id: id)
                                }
                            })
                        }
                    })
                }
            }
            

        }
    }
    func regsiter(block:@escaping NETBLock){
        if isRegin{
            block(true)
            return
        }
        Thread.sleep(forTimeInterval: Double.random(in: 1..<5))
        block(true)
        isRegin = true
    }
    func load(block:@escaping NETBLock){
        Thread.sleep(forTimeInterval: Double.random(in: 1..<5))
        block(Bool.random())
    }
    func login(block:@escaping NETBLock){
        Thread.sleep(forTimeInterval: Double.random(in: 1..<5))
        block(true)
    }
//2:Operation
//用的不多,忽略了

}
上面的GCD写法可以说是传统写法了.我这里要先注册,再执行下一步,但是预防并发注册,所以这种写法,有更优化方法欢迎提出
接下来说到新语法

enum NetError : Error {
        case netfail
    }
    func login() async throws -> Bool {
        let isNet = Bool.random()
        if isNet {
            // 模拟网络延迟
            try await Task.sleep(nanoseconds: UInt64.random(in: 1_000_000_000..<5_000_000_000))
            return true
        } else {
            // 抛出网络错误
            throw NetError.netfail
        }
    }
    func regsin()async ->Bool{
        // 模拟网络延迟
        do{
            try await Task.sleep(nanoseconds: UInt64.random(in: 1_000_000_000..<5_000_000_000))
            return true
        }catch{
            return false
        }
    }
    func loadApi()async->Bool{
        // 模拟网络延迟
        do{
            try await Task.sleep(nanoseconds: UInt64.random(in: 1_000_000_000..<5_000_000_000))
            return true
        }catch{
            return false
        }
    }
    func load(){
        Task {
            let isRegin = await regsin()
            //注册成功
            if isRegin{
                let apiResult = await loadApi()
                //如果api请求失败
                if !apiResult{
                    //重新调用登录接口,调用成功后,重新请求
                    if let loginResult = try? await login(){
                        load()
                    }
                }
            }
        }
    }

用Task可以处理某些必须串行队列,和多个异步block嵌套的问题,更加简介
这里介绍异步block 和 async 搭配用法

func asyncBlock(block:@escaping ((Bool)->Void)){
        Thread.sleep(forTimeInterval: Double.random(in: 1..<5))
        block(true)
    }
    func loadData()async -> Bool{
        return await withCheckedContinuation { continuation in
            asyncBlock { result in
                continuation.resume(returning: result)
            }
        }
    }
//返回当前线程
  func getData()->Task<Void, Error>{
        let task = Task {
//检查当前线程是否被取消
            try Task.checkCancellation()
            let result = await loadData()
        }
        return task
    }
//取消线程示例
    func cancelGetData(){
        let task = getData()
//取消线程
        task.cancel()
    }

//对于这个语法我更喜欢的一点是,一个数组需要遍历,进行异步操作
///假设我需要用当前index 和 index - 1 的数据进行异步数据比对,最后遍历完成将所有数据汇总
传统方法:只有用信号量加线程组的方式,较难把控逻辑是否完整,和并发数量整体控制
如果用task 可以更加清晰的完成这个逻辑

上述的方法包含我对task 和 async,await 理解. 在swiftUI中新的异步语法会更加附和语言特性.如有不足或者错误,请及时帮我指出.谢谢阅读到此处