美文网首页iOS-项目实战iOS-多线程
Swift GCD之解决多个网络请求的尴尬

Swift GCD之解决多个网络请求的尴尬

作者: GuiiLiin | 来源:发表于2020-06-11 18:24 被阅读0次
    • 项目开发过程中, 经常遇到单个页面需要发起多个网络请求, 而且还需要控制执行顺序或者所有请求结束后统一处理数据的情况. 最明显的解决方案就是嵌套,但是如果请求多了,代码确实有点恶心

    DispatchQueue

    • 串行队列的创建
    let queue = DispatchQueue(label: "myQueue")
    
    • 并行队列的创建, 参数说明
      • label: 随意命名,队列的标识
      • qos(服务质量): DispatchQoS.default DispatchQoS.background(后台执行) DispatchQoS.unspecified(不指定) DispatchQoS.userInitiated(用户发起) 等
      • attributes: DispatchQueue.Attributes.concurrent(并行队列) 不指定的情况是串行队列
      • autoreleaseFrequency(自动释放的频度): inherit(继承) workItem(工作组) never(从不)
    let queue = DispatchQueue(label: "myQueue", qos: DispatchQoS.default, attributes: DispatchQueue.Attributes.concurrent, autoreleaseFrequency: DispatchQueue.AutoreleaseFrequency.inherit, target: nil)
    
    • 简单使用
    let queue = DispatchQueue(label: "myQueue", qos: DispatchQoS.default, attributes: DispatchQueue.Attributes.concurrent, autoreleaseFrequency: DispatchQueue.AutoreleaseFrequency.inherit, target: nil)
    
    queue.async {
        sleep(1)
        print("in queue 111")
    }
    queue.async {
        sleep(1)
        print("in queue 222")
    }
    
    print("finish")
    
    image

    DispatchGroup(进入正题)

    线程组有两种模式, 阻塞式(DispatchGroup-wait) 和 非阻塞式(DispatchGroup-notify)

    wait

    workingGroup.enter() 和 workingGroup.leave() 要成对出现, 只有leave()之后才会开始新的enter()
    队列中的请求任务是否顺序执行, 取决于自己创建的队列类型

    // DispatchGroup-wait(阻塞)
    let workingGroup = DispatchGroup()
    let workingQueue = DispatchQueue(label: "request_queue") // 这个是串行的队列, queue里面的任务会顺序执行
    //let workingQueue = DispatchQueue(label: "request_queue1", qos: DispatchQoS.default, attributes: DispatchQueue.Attributes.concurrent, autoreleaseFrequency: DispatchQueue.AutoreleaseFrequency.inherit, target: nil) // 这个是并行队列, queue里面的任务会同时执行
    
    workingGroup.enter() // 开始
    workingQueue.async {
        Thread.sleep(forTimeInterval: 2)
        print("接口 A 数据表请求完成")
        workingGroup.leave() // 结束
    }
    
    workingGroup.enter() // 开始
    workingQueue.async {
        Thread.sleep(forTimeInterval: 1)
        print("接口 B 数据表请求完成")
        workingGroup.leave() // 结束
    }
    print("========= 我是最开始执行的 =========")
    
    workingGroup.wait() // 阻塞, 直到Group中的任务都结束
    
    print("接口 A 和接口 B 的数据都已经请求完毕, 开始合并两个接口的数据")
    print("========= 完美结束完美结束 =========")
    
    image

    notify

    任务结束后, 通过通知回调的方式继续执行, 同时不会阻塞线程

    // DispatchGroup-notify(不阻塞)
    let workingGroup1 = DispatchGroup()
    //let workingQueue1 = DispatchQueue(label: "request_queue1", qos: DispatchQoS.default, attributes: DispatchQueue.Attributes.concurrent, autoreleaseFrequency: DispatchQueue.AutoreleaseFrequency.inherit, target: nil) // 创建并行队列
    let workingQueue1 = DispatchQueue(label: "request_queue1") // 创建的默认队列是串行队列
    
    workingGroup1.enter()
    workingQueue1.async {
        Thread.sleep(forTimeInterval: 2)
        print("接口 C 数据表请求完成")
        workingGroup1.leave()
    }
    
    workingGroup1.enter()
    workingQueue1.async {
        Thread.sleep(forTimeInterval: 1)
        print("接口 D 数据表请求完成")
        workingGroup1.leave()
    }
    
    print("↓↓↓↓↓↓↓↓↓↓↓↓↓↓ 我是最开始执行的 ↓↓↓↓↓↓↓↓↓↓↓↓↓↓")
    workingGroup.notify(queue: workingQueue1) {
        print("接口 C 和接口 D 的数据都已经请求完毕, 开始合并两个接口的数据")
    }
    
    print("验证不阻塞 O(∩_∩)O哈哈~")
    
    
    image

    结束语

    妈妈再也不用担心我了

    通过实际操作, 同时发起多个网络请求, 发现以上的两种方式, 只是控制了请求的顺序, 并没有控制返回数据的顺序, 然后心态崩了, 只是崩了一小会儿, 继续往下, 问题解决

    swift中的信号量使用

    // 创建初始值为0的信号量,这时代表是红灯
    let sema = DispatchSemaphore(value: 0)
    
    // 让信号量 -1,比如默认值时0, wait()以后就变成了 -1了,因此会等待
    sema.wait()
    
    // 让信号量 +1, 当>0时就代表绿灯可以走了
    sema.signal()
    
    
    let workingGroup = DispatchGroup()
    let workingQueue = DispatchQueue(label: "request_queue")
    
    workingGroup.enter() // 开始
    workingQueue.async {
        let sema = DispatchSemaphore(value: 0)
        let params = ["id": "458"]
        self.req1(params, sema: sema)
        sema.wait() // 等待任务结束, 否则一直阻塞
        workingGroup.leave() // 结束
    }
    workingGroup.enter() // 开始
    workingQueue.async {
        let sema = DispatchSemaphore(value: 0)
        self.req2(self.productId, sema: sema)
        sema.wait() // 等待任务结束, 否则一直阻塞
        workingGroup.leave() // 结束
    }
    
    workingGroup.notify(queue: DispatchQueue.main) {
        // 全部调用完成后回到主线程,更新UI
    }
    
    private func req1(_ params: [String: Any], sema: DispatchSemaphore) {
        LBProductNetManager.req_addOrApplyNow(params: params, success: { (result) in
            // 信号量+1
            sema.signal()
        }) { (error) in
            // 失败的时候也要+1, 否则会永远阻塞了
            sema.signal()
        }
    }
    
    private func req2(_ productId: Int, sema: DispatchSemaphore) {
        LBProductNetManager.req_getHealthNotice(213, success: { (result) in
            // 信号量+1
            sema.signal()
        }) { (error) in
            // 失败的时候也要+1, 否则会永远阻塞了
            sema.signal()
        }
    }
    

    摘自 Chaos_G 本文仅作为学习使用 如有侵权 麻烦联系我 立即删除

    相关文章

      网友评论

        本文标题:Swift GCD之解决多个网络请求的尴尬

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