关于多个网络请求同步的一些总结

作者 Tsui YuenHong 日期 2017-01-09
关于多个网络请求同步的一些总结

等待多个并发请求同步回调

例如同时发起网络请求A,网络请求B,网络请求C,需等待A,B,C都返回了才进行回调。曾经是利用 block 嵌套,就是A回调嵌B,B回调嵌C,十分肤浅的做法╮(╯▽╰)╭
这里介绍 GCD 中的两种方法,第一种是利用 DispatchGroupenterleave,第二种是利用 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 函数。
这种方法的原理就是:

  1. 请求前 enter
  2. 请求完成后 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也是必须成对出现。
这种方法的原理就是:

  1. 创建0信号量。
  2. 请求完成释放信号,使得信号量+1。
  3. 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_asyncdispatch_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 几乎全部换新,具体使用必须看官方文件。