信号量
之前遇到一个问题，一个请求需要在另一个请求获得的参数。这个时候最开始的办法是把第二个请求写在第一个请求的回调里，但是这样的话，两个请求就很紧密的耦合在一起了。这个时候可以使用信号量来使他们分离开来。
先看下相关的3个方法：
dispatch_semaphore_t dispatch_semaphore_create(long value)：方法接收一个long类型的参数, 返回一个dispatch_semaphore_t类型的信号量，值为传入的参数long dispatch_semaphore_wait(dispatch_semaphore_t dsema, dispatch_time_t timeout)：接收一个信号和时间值，若信号的信号量为0，则会阻塞当前线程，直到信号量大于0或者经过输入的时间值；若信号量大于0，则会使信号量减1并返回，程序继续住下执行long dispatch_semaphore_signal(dispatch_semaphore_t dsema)：使信号量加1并返回
下面看几种使用方法
保持线程同步1
2
3
4
5
6
7
8
9let semaphore = DispatchSemaphore.init(value: 0)
var i = 10
DispatchQueue.global().async {
i = 100
semaphore.signal()
}
semaphore.wait()
print("i = \(i)")
输出i ＝ 100
如果注掉semaphore.wait()这一行，则 i ＝ 10
注释： 由于是将block异步添加到一个并行队列里面，所以程序在主线程跃过block直接到semaphore.wait()这一行，因为semaphore信号量为0，所以当前线程会一直阻塞，直到block在子线程执行到semaphore.signal()，使信号量+1，此时semaphore信号量为1了，所以程序继续往下执行。这就保证了线程间同步了。
为线程加锁(同时可以控制最大并发数量 , value 的值等于几就是最多几个并发)1
2
3
4
5
6
7
8
9let semaphore = DispatchSemaphore.init(value: 1)
for i in 0..<100 {
DispatchQueue.global().async {
semaphore.wait()
print("i = \(i)")
semaphore.signal()
}
}
注释：当线程1执行到semaphore.wait()这一行时，semaphore的信号量为1，所以使信号量-1变为0，并且线程1继续往下执行；如果当在线程1的print这一行代码还没执行完的时候，又有线程2来访问，执行semaphore.wait()时由于此时信号量为0(.wait()方法默认时间是 OC 的DISPATCH_TIME_FOREVER)，所以会一直阻塞线程2（此时线程2处于等待状态），直到线程1执行完print并执行完semaphore.signal()使信号量为1后，线程2才能解除阻塞继续住下执行。以上可以保证同时只有一个线程执行print这一行代码。
栅栏函数(barrier)
等待异步执行多个任务后, 再执行下一个任务，一般使用barrier函数1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34//创建串行队列
// let queue = DispatchQueue.init(label: "test", qos: .default, attributes: .init(rawValue: 0), autoreleaseFrequency: .workItem, target: nil)
//创建并行队列
let queue = DispatchQueue.init(label: "test", qos: .default, attributes: .concurrent, autoreleaseFrequency: .workItem, target: nil)
queue.async {//任务一
for _ in 0...3 {
print("......")
}
}
queue.async {//任务二
for _ in 0...3 {
print("++++++");
}
}
queue.async(group: nil, qos: .default, flags: .barrier) {
print("group")
}
queue.async {
print("finish")
}
最后打印
......
++++++
++++++
++++++
++++++
......
......
......
group
finish
注释:使用barrier函数可以做到先让前面的任务执行完毕，再执行之后的任务，会阻塞当前的线程
延时任务
1 | let queue = DispatchQueue.init(label: "test", qos: .default, attributes: .concurrent, autoreleaseFrequency: .workItem, target: nil) |
_注释_：10s后提交。并且不会阻碍当前线程
组的用法(Group)
notify(依赖任务)1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38let queue = DispatchQueue.init(label: "test", qos: .default, attributes: .concurrent, autoreleaseFrequency: .workItem, target: nil)
let group = DispatchGroup()
queue.async(group: group, qos: .default, flags: [], execute: {
for _ in 0...10 {
print("耗时任务1")
}
})
queue.async(group: group, qos: .default, flags: [], execute: {
for _ in 0...10 {
print("耗时任务2")
}
})
//执行完上面的两个耗时操作, 回到myQueue队列中执行下一步的任务
group.notify(queue: queue) {
print("回到该队列中执行")
}
queue.async {
print("完成")
}
打印：
耗时任务2
完成
耗时任务1
耗时任务2
耗时任务2
耗时任务2
耗时任务2
耗时任务1
耗时任务2
耗时任务1
耗时任务1
耗时任务1
耗时任务1
回到该队列中执行
注释：使用group+notify的话，也会等待之前的任务先执行完，和barrier的区别是不会阻碍当前的线程
wait(等待任务)1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41let queue = DispatchQueue.init(label: "test", qos: .default, attributes: .concurrent, autoreleaseFrequency: .workItem, target: nil)
let group = DispatchGroup()
queue.async(group: group, qos: .default, flags: [], execute: {
for _ in 0...5 {
print("耗时任务1")
}
})
queue.async(group: group, qos: .default, flags: [], execute: {
for _ in 0...5 {
print("耗时任务2")
}
})
//等待上面任务执行，会阻塞当前线程，超时就执行下面的，上面的继续执行。可以无限等待 .distantFuture
let result = group.wait(timeout: .now() + 2.0)
switch result {
case .success:
print("不超时, 上面的两个任务都执行完")
case .timedOut:
print("超时了, 上面的任务还没执行完执行这了")
}
print("接下来的操作")
打印：
耗时任务1
耗时任务2
耗时任务1
耗时任务2
耗时任务1
耗时任务2
耗时任务1
耗时任务2
耗时任务1
耗时任务2
耗时任务1
耗时任务2
不超时, 上面的两个任务都执行完
接下来的操作
注释:使用wait+group的话，如果设置timeout = .distantFuture的话，那么就和barrier函数一样了，会等待之前的完成，否则就是等待之前的完成或者等待设置的时间到了，就会执行接下来的任务了，会阻塞当前现场。