Swift_技巧(2)_GCD的使用总结

OC版本:http://www.jianshu.com/p/25b59832b302

一丶介绍

目录:

1.多个网络请求并发处理
2.分线程/主线程通讯
3.延迟执行
4.队列组的使用
5.信号量

官方api

https://developer.apple.com/reference/dispatch

二丶代码

1.多个网络请求并发处理;

//1.多个网络请求并发处理;
let  dispatchGroup = DispatchGroup.init()
//延迟执行
let delay =  DispatchTime.now() + .seconds(1);
print("准备做第一件事");
dispatchGroup.enter();
DispatchQueue.main.asyncAfter(deadline: delay) {
    
    print("延迟1秒做的事情结束");
    dispatchGroup.leave();
}
//延迟执行
let delay2 =  DispatchTime.now() + .seconds(3);
print("准备做第二件事");
dispatchGroup.enter();
DispatchQueue.main.asyncAfter(deadline: delay2) {
    
    print("延迟3秒做的事情结束");
    dispatchGroup.leave();
}

dispatchGroup.notify(queue: DispatchQueue.main) {
    print("全部完成");
}

2分线程/主线程通讯

//2分线程/主线程通讯
DispatchQueue.global().async {
    
    DispatchQueue.main.async {
        
    }
}

3.延迟执行

//3延迟执行
let delay =  DispatchTime.now() + .seconds(3);
print("开始");
DispatchQueue.main.asyncAfter(deadline: delay) {
    
    print("结束");
}

4.队列组的使用

//4,队列组的使用
let group = DispatchGroup.init();
let queue1 = DispatchQueue.init(label: "Queue")
//组,优先级,
queue1.async(group: group, qos: .default, flags: .barrier, execute: {
    for _ in 0...5 {
        print(" Q1____> \(Thread.current)")
    }
})
queue1.async(group: group, qos: .default, flags: .barrier, execute: {
    for _ in 0...3 {
        print(" Q2____> \(Thread.current)")
    }
})

queue1.async(group: group, qos: .default, flags: .barrier, execute: {
    for _ in 0...4 {
        print(" Q3____> \(Thread.current)")
    }
})
group.notify(queue: queue1) {
    
    print(" 完成__> \(Thread.current)")
}

5.信号量

//5信号量
let singnal = DispatchSemaphore.init(value: 1);
//-1
singnal.wait();
//+1
singnal.signal();

例子:
所有线程都必须做一件事情,只要有1个线程做完,其他线程就不用做的情景:

var _count :Int = 0
var _signal: DispatchSemaphore = DispatchSemaphore.init(value: 1)

override func touchesBegan(_ touches: Set, with event: UIEvent?) {
    
    /*
     三个线程同时处理xzb()
     */
    _count = 0;
    for var index in 0...3 {
        index += 1
        DispatchQueue.global().async {
            self.xzb(name: "\(index)")
        }
    }
}
//  如果 count < 10 则让 count 累加且只能有一个线程做,如果有一个线程去做累加,其他线程则等待;
func xzb(name: String) -> () {
    print("准备开始-->" + name)
    _signal.wait();
    if _count < 10 {
        for _ in 0...10 {
            _count += 1
            print(_count)
        }
    }
    _signal.signal();
    print("结束")
}

日志:

准备开始-->1
准备开始-->4
准备开始-->2
准备开始-->3
1
2
3
4
5
6
7
8
9
10
11
结束
结束
结束
结束

三丶扩展

qos:线程优先级

和原有的对应关系是：

* DISPATCH_QUEUE_PRIORITY_HIGH:         .userInitiated
* DISPATCH_QUEUE_PRIORITY_DEFAULT:      .default
* DISPATCH_QUEUE_PRIORITY_LOW:          .utility
* DISPATCH_QUEUE_PRIORITY_BACKGROUND:   .background

flags:

原文
DispatchWorkItemFlags
DispatchWorkItemFlags are an option set that configure the 
behavior of a DispatchWorkItem value, including its quality of 
service class and whether to create a barrier or spawn a new 
detached thread.

创建一个屏障或者新的独立线程?听不懂看个例子:
barrier
假设我们有一个并发的队列用来读写一个数据对象。如果这个队列里
的操作是读的，那么可以多个同时进行。如果有写的操作，则必须保
证在执行写入操作时，不会有读取操作在执行，必须等待写入完成后
才能读取，否则就可能会出现读到的数据不对。
__例子选自网友[不灭的小灯灯]的文章;

四丶总结

真是任性,api样子变动太大了,一些api都废弃掉了;
看我表情:
![]G(9J4XSDVSFB%@F(TZ38FX.gif](http://upload-images.jianshu.io/upload_images/1986326-7a2dbb1901d8e232.gif?imageMogr2/auto-orient/strip)