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

项目开发过程中, 经常遇到单个页面需要发起多个网络请求, 而且还需要控制执行顺序或者所有请求结束后统一处理数据的情况. 最明显的解决方案就是嵌套,但是如果请求多了,代码确实有点恶心

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

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("========= 完美结束完美结束 =========")

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哈哈~")

结束语

妈妈再也不用担心我了

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

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