等待多个并发请求同步回调
例如同时发起网络请求A，网络请求B，网络请求C，需等待A，B，C都返回了才进行回调。曾经是利用 block 嵌套，就是A回调嵌B，B回调嵌C，十分肤浅的做法╮(╯▽╰)╭
这里介绍 GCD 中的两种方法，第一种是利用 DispatchGroup 的 enter 和 leave，第二种是利用 DispatchSemaphore 信号量。
以下代码是基于 swift 3.0.2。
首先先创建一个模拟请求。
// 假装是网络请求
func networkRequest(sleepTime: Int, closure: @escaping ()->Void) -> Void {
DispatchQueue.global().async {
Thread.sleep(forTimeInterval: TimeInterval(sleepTime))
// 假装是成功回调
closure()
}
}
第一种方法利用 enter&leave。需要注意的是 enter&leave 必须成对出现，enter 少了会崩溃，leave 少了则永远不会执行 notify 函数。
这种方法的原理就是：
- 请求前
enter。 - 请求完成后
leave。
// 利用 enter/leave 来控制
func gcd_group_enter_leave() {
let group = DispatchGroup.init()
let queue = DispatchQueue.global()
queue.async(group: group) {
group.enter()
print("1 start")
self.networkRequest(sleepTime:1, closure: {
print("1 end")
group.leave()
})
}
queue.async(group: group) {
group.enter()
print("2 start")
self.networkRequest(sleepTime:2, closure: {
print("2 end")
group.leave()
})
}
queue.async(group: group) {
group.enter()
print("3 start")
self.networkRequest(sleepTime:2, closure: {
print("3 end")
group.leave()
})
}
queue.async(group: group) {
group.enter()
print("4 start")
self.networkRequest(sleepTime:2, closure: {
print("4 end")
group.leave()
})
}
group.notify(queue: queue) { // 所有组完成后回调
print("all done")
}
}
第二种方法是利用信号量的 wait&signal，简单来说就是：signal 就是释放信号即信号量 +1，wait 就是等待信号即信号量-1。wait&signal也是必须成对出现。
这种方法的原理就是：
- 创建0信号量。
- 请求完成释放信号，使得信号量+1。
-
notify的回调操作前加入wait操作(多少请求就加多少wait，这要做为了得到足够的信号量才能执行wait下面的代码）。
// 利用 semaphore 来控制
func gcd_semaphore_wait_signal() {
let semaphore = DispatchSemaphore.init(value: 0)
let group = DispatchGroup.init()
let queue = DispatchQueue.global()
queue.async(group: group) {
self.networkRequest(sleepTime:1, closure: {
print("1")
semaphore.signal()
})
}
queue.async(group: group) {
self.networkRequest(sleepTime:2, closure: {
print("2")
semaphore.signal()
})
}
queue.async(group: group) {
self.networkRequest(sleepTime:2, closure: {
print("3")
semaphore.signal()
})
}
group.notify(queue: queue) {
semaphore.wait()
semaphore.wait()
semaphore.wait()
print("all done")
}
}
多个相关请求顺序执行
有时候开发中也会遇到利用网络请求A返回的的数据来进行网络请求B，以前也是十分肤浅地利用嵌套，虽然简单可行而且可以减少中间变量，但是出现过多嵌套代码不易debug。这里也是可以利用 DispatchSemaphore 信号量。网络请求A完成后 signal，而网络请求B发起前 wait。
// 利用 semaphore 来控制
func gcd_line_request() {
let semaphore = DispatchSemaphore.init(value: 0)
let group = DispatchGroup.init()
let queue = DispatchQueue.global()
queue.async(group: group) {
self.networkRequest(sleepTime:1, closure: {
print("1")
semaphore.signal()
})
}
queue.async(group: group) {
semaphore.wait()
self.networkRequest(sleepTime:2, closure: {
print("2")
})
}
}
当然也可以利用RAC，在A请求完成后发送信号唤醒B执行即可，还可以传递参数。
// 利用 rac 来控制
func rac_request() {
let (requestA, observerA) = Signal<Bool, NoError>.pipe()
self.networkRequest(sleepTime: 1) {
print("网络请求A完成")
observerA.send(value: true) //网络请求完成并且是成功的
observerA.sendCompleted()
}
requestA.observeValues { (success) in
if success {
self.networkRequest(sleepTime: 1, closure: {
print("网络请求B完成")
})
}
}
}
顺便说说栅栏函数 dispatch_barrier_async
这是可以在并行队列中插入一个操作，例如任务1234都是并行的，如果在代码中12和34插入dispatch_barrier_async 则可以保证 dispatch_barrier_async 中的内容在12后、34前执行。
func test() {
let group = DispatchGroup.init()
let queue = DispatchQueue.init(label: "xQ")
queue.async(group: group) {
print("1 start")
}
queue.async(group: group) {
print("2 start")
}
queue.async(group: group, flags: .barrier) {
print("5 start")
}
queue.async(group: group) {
print("3 start")
}
queue.async(group: group) {
print("4 start")
}
}
这里可以保证输出为 12/21 5 34/43 这样的顺序，5肯定夹在中间。
不过注意这里有个十分坑的地方：对于 DispatchQueue.global() 这个函数不起效！
在 swift 文档中并没有提到，我是在看 OC 文档中发现的解释，对 DispatchQueue.global() 不起效，仅相当于 dispatch_async，dispatch_barrier_async 只对自己创建的队列才生效。
The queue you specify should be a concurrent queue that you create yourself using the dispatch_queue_create function. If the queue you pass to this function is a serial queue or one of the global concurrent queues, this function behaves like the dispatch_async function.
最后说一句，swift3 中的 GCD 几乎全部换新，具体使用必须看官方文件。
