swift GCD线程

一、基本概念：同步, 异步, 并发, 串行
同步和异步决定了要不要开启新的线程

1.同步(sync): 在当前线程中执行任务, 不具备开启新线程的能力

2.异步(async): 在新的线程中执行任务, 具备开启新线程的能

并发和串行决定了任务的执行方式

1.并发(Concurrent): 多个任务并发(同时)执行

2.串行(Serial): 一个任务执行完毕后, 再执行下一个任务(顺序执行)

二、队列创建
1、串行队列
let queue1 = DispatchQueue.init(label: "Serial queue1")//label:队列标识符
如果想指定串行队列的优先级, 可使用下面的方法来创建:
let queue2 = DispatchQueue.init(label: "QueueIdentifier", qos: DispatchQoS.userInitiated)

参数qos: 用于指定队列的优先级, 是个枚举:
 
 .userInteractive //用户交互(跟主线程一样)
 .userInitiated   //用户期望优先级（不要放太耗时的操作）
 .default         //默认的
 .utility         //公共的
 .background      //后台
 .unspecified     //不指定
 
 优先级, 由上往下依次降低

最常用的串行队列---主队列
let mainQueue = DispatchQueue.main

2、并行队列
和创建串行队列的方法一样, 只不过多了一个参数attributes, 传 .concurrent 即可创建一个并行队列

label 队列的标识符，方便调试
qos 用于指定队列的优先级
attributes 队列的属性
autoreleaseFrequency。顾名思义，自动释放频率。有些队列是会在履行完任务后自动释放的，有些比如Timer等是不会自动释放的，是需要手动释放。

let queue3 = DispatchQueue.init(label: "com.gcd.queue", qos: DispatchQoS.default, attributes: DispatchQueue.Attributes.concurrent, autoreleaseFrequency: DispatchQueue.AutoreleaseFrequency.workItem, target: nil)

在使用的时候, 我们一般不去创建并行队列, 而是使用系统为我们提供的全局的并行队列:

let queue4 = DispatchQueue.global()

也可以制定优先级

let queue5 = DispatchQueue.global(qos: .default)
注意:
在创建串行并行队列的时候, 参数attributes, 可以指定创建的是串行还是并行队列, 他还有一个值: .initiallyInactive, 即: 创建的时候, 是处于不活跃状态, 即不会执行任务, 需要手动调用activate()来激活队列执行任务

三、GCD常用的方法
1、开线程异步执行完耗时代码，返回主线程刷新UI
func GCDTest1() {
DispatchQueue.global().async {//并行、异步
print("开一条全局队列异步执行任务")
DispatchQueue.main.async {//串行、异步
print("在主队列执行刷新界面任务")
}
}
}
2、等待异步执行多个任务后, 再执行下一个任务
func GCDTest2() {
let myQueue = DispatchQueue(label: "com.myQueue", qos: .default, attributes: .concurrent, autoreleaseFrequency: .workItem, target: nil)//并行队列
myQueue.async {//任务一
for _ in 0...10 {
print("任务1......")
}
}
myQueue.async {
for _ in 0...5 {
print("任务2++++++")
}
}
// barrier 会等待上面执行完毕再执行下面的，会阻塞当前线程
myQueue.async(group: nil, qos: .default, flags: .barrier, execute: {//2.
print("000000")
})

    myQueue.async {
        print("111111")
    }
}

打印输出:
任务1......
任务1......
任务1......
任务1......
任务1......
任务1......
任务1......
任务1......
任务1......
任务1......
任务1......
任务2++++++
任务2++++++
任务2++++++
任务2++++++
任务2++++++
任务2++++++
000000
111111

3、延时提交任务
func GCDTest3() {
print("延时提交的任务--GCDTest3")
//主队列
DispatchQueue.main.asyncAfter(deadline: DispatchTime.now() + 3) {
print("延时提交的任务--main")
}

    //指定队列
    let myQueue = DispatchQueue(label: "com.myQueue", qos: .default, attributes: .concurrent, autoreleaseFrequency: .workItem, target: nil)//并行队列
    myQueue.asyncAfter(deadline: DispatchTime.now() + 3, execute: {
        print("延时提交的任务--myQueue")
    })
    
    let delayTime = DispatchTimeInterval.seconds(2)
    myQueue.asyncAfter(deadline: DispatchTime.now()+delayTime) {
        print("延时提交的任务--delayTime")

    }
}

打印输出:
延时提交的任务--GCDTest3
延时提交的任务--delayTime
延时提交的任务--main
延时提交的任务--myQueue

4、信号量--控制最大并发数
信号量的说明:
GCD 信号量控制并发 （dispatch_semaphore）
当我们在处理一系列线程的时候，当数量达到一定量，在以前我们可能会选择使用NSOperationQueue来处理并发控制，但如何在GCD中快速的控制并发呢？答案就是dispatch_semaphore。
信号量是一个整形值并且具有一个初始计数值，并且支持两个操作：信号通知和等待。当一个信号量被信号通知，其计数会被增加。当一个线程在一个信号量上等待时，线程会被阻塞（如果有必要的话），直至计数器大于零，然后线程会减少这个计数。

在GCD中有三个函数是semaphore的操作，分别是：
1、dispatch_semaphore_create　　　创建一个semaphore
2、dispatch_semaphore_signal　　　发送一个信号
3、dispatch_semaphore_wait　　　　等待信号

关于信号量，一般可以用停车来比喻:

*停车场剩余4个车位，那么即使同时来了4辆车也能停的下。如果此时来了5辆车，那么就有一辆需要等待。
*信号量的值就相当于剩余车位的数目，dispatch_semaphore_wait 函数就相当于来了一辆车，dispatch_semaphore_signal就相当于走了一辆车

停车位的剩余数目在初始化的时候就已经指明了（dispatch_semaphore_create（long value），
调用一次dispatch_semaphore_signal，剩余的车位就增加一个；
调用一次dispatch_semaphore_wait剩余车位就减少一个；
当剩余车位为0时，再来车（即调用dispatch_semaphore_wait）就只能等待。

有可能同时有几辆车等待一个停车位。
有些车主没有耐心，给自己设定了一段等待时间，这段时间内等不到停车位就走了，如果等到了就开进去停车。
而有些车主就像把车停在这，所以就一直等下去.

下面我们逐一介绍三个函数：

（1）dispatch_semaphore_create的声明为：
dispatch_semaphore_t dispatch_semaphore_create(long value);

传入的参数为long，输出一个dispatch_semaphore_t类型且值为value的信号量。
值得注意的是，这里的传入的参数value必须大于或等于0，否则dispatch_semaphore_create会返回NULL。

（2）dispatch_semaphore_signal的声明为：
　　
long dispatch_semaphore_signal(dispatch_semaphore_t dsema)

这个函数会使传入的信号量dsema的值加1；

(3) dispatch_semaphore_wait的声明为：
　　
long dispatch_semaphore_wait(dispatch_semaphore_t dsema, dispatch_time_t timeout)；

这个函数会使传入的信号量dsema的值减1。
这个函数的作用是这样的，如果dsema信号量的值大于0，该函数所处线程就继续执行下面的语句，并且将信号量的值减1；
如果desema的值为0，那么这个函数就阻塞当前线程等待timeout（注意timeout的类型为dispatch_time_t，不能直接传入整形或float型数），如果等待的期间desema的值被dispatch_semaphore_signal函数加1了，且该函数（即dispatch_semaphore_wait）所处线程获得了信号量，那么就继续向下执行并将信号量减1。
如果等待期间没有获取到信号量或者信号量的值一直为0，那么等到timeout时，其所处线程自动执行其后语句。

（4）dispatch_semaphore_signal的返回值为long类型，
当返回值为0时表示当前并没有线程等待其处理的信号量，其处理的信号量的值加1即可。
当返回值不为0时，表示其当前有（一个或多个）线程等待其处理的信号量，并且该函数唤醒了一个等待的线程（当线程有优先级时，唤醒优先级最高的线程；否则随机唤醒）。

dispatch_semaphore_wait的返回值也为long型。
当其返回0时表示在timeout之前，该函数所处的线程被成功唤醒。
当其返回不为0时，表示timeout发生。

//每十个任务并发执行
func GCDTest4() {
let group = DispatchGroup.init()
let queue = DispatchQueue.global()
//剩余10个车位
let semaphore = DispatchSemaphore.init(value: 10)
for i in 1...100 {

        //来了一辆车，信号量减1
        let result = semaphore.wait(timeout: .distantFuture)
        if result == .success {
            queue.async(group: group, execute: {
                print("队列执行\(i)--\(Thread.current)")
                //模拟执行任务时间
                sleep(3)
                //延迟3s后,走了一辆车，信号量+1
                semaphore.signal()
            })
        }
    }
    group.wait()
}

5、Group的用法
你想某个任务在其他任务执行之后再执行, 或者必须某个任务执行完,才能执行下面的任务, 可以使用DispatchGroup:

notify(依赖任务)
func GCDTest5() {
let group = DispatchGroup.init()
let myQueue = DispatchQueue(label: "com.myQueue", qos: .default, attributes: .concurrent, autoreleaseFrequency: .workItem, target: nil)//并行队列
myQueue.async(group: group, qos: .default, flags: []) {
for _ in 0...10 {
print("耗时任务1。。。。")
}
}
myQueue.async(group: group, qos: .default, flags: []) {
for _ in 0...10 {
print("耗时任务2。。。。")
}
}
//执行完上面的两个耗时操作, 回到myQueue队列中执行下一步的任务
group.notify(queue: myQueue) {
print("notify--回到该队列中执行")
}
}
打印输出:
耗时任务2。。。。
耗时任务1。。。。
耗时任务2。。。。
耗时任务1。。。。
耗时任务2。。。。
耗时任务1。。。。
耗时任务2。。。。
耗时任务1。。。。
耗时任务2。。。。
耗时任务1。。。。
耗时任务2。。。。
耗时任务1。。。。
耗时任务2。。。。
耗时任务1。。。。
耗时任务2。。。。
耗时任务1。。。。
耗时任务2。。。。
耗时任务1。。。。
耗时任务2。。。。
耗时任务1。。。。
耗时任务2。。。。
耗时任务1。。。。
notify--回到该队列中执行

func GCDTest6() {
    let queue = DispatchQueue(label: "queueName", attributes: .concurrent)
    queue.async {
        sleep(3)
        print("任务 1")
    }
    queue.async {
        sleep(2)
        print("任务 2")
    }
    queue.async {
        sleep(1)
        print("任务 3")
    }
    DispatchGroup.init().notify(qos: .default, flags: .barrier, queue: queue) {
        print("所有任务结束")
    }
    print("任务结束")
}

打印输出:

任务结束
任务 3
任务 2
任务 1
所有任务结束

wait(任务等待)
func GCDTest7() {
let group = DispatchGroup.init()
let myQueue = DispatchQueue(label: "com.myQueue", qos: .default, attributes: .concurrent, autoreleaseFrequency: .workItem, target: nil)//并行队列
myQueue.async(group: group, qos: .default, flags: []) {
for _ in 0...10 {
print("耗时任务1。。。。")
}
}
myQueue.async(group: group, qos: .default, flags: []) {
for _ in 0...10 {
print("耗时任务2。。。。")
sleep(UInt32(1))//阻塞当前线程。一旦看到这句话，当前线程挂起给定时间后执行下一句
}
}
//等待上面任务执行，会阻塞当前线程，超时就执行下面的，上面的继续执行。可以无限等待 .distantFuture
let result = group.wait(timeout: .now() + 5.0)
switch result {
case .success:
print("不超时, 上面的两个任务都执行完")
case .timedOut:
print("超时了, 上面的任务还没执行完执行这了")
}
print("接下来的操作")
}

输出打印：
耗时任务1。。。。
耗时任务2。。。。
耗时任务1。。。。
耗时任务1。。。。
耗时任务1。。。。
耗时任务1。。。。
耗时任务1。。。。
耗时任务1。。。。
耗时任务1。。。。
耗时任务1。。。。
耗时任务1。。。。
耗时任务1。。。。
耗时任务2。。。。
耗时任务2。。。。
耗时任务2。。。。
耗时任务2。。。。
超时了, 上面的任务还没执行完执行这了
接下来的操作
耗时任务2。。。。
耗时任务2。。。。
耗时任务2。。。。
耗时任务2。。。。
耗时任务2。。。。
耗时任务2。。。。

如果将上面的 sleep(UInt32(1)) 注释掉，则执行不超时方法

输出打印：
耗时任务1。。。。
耗时任务2。。。。
耗时任务1。。。。
耗时任务2。。。。
耗时任务1。。。。
耗时任务2。。。。
耗时任务1。。。。
耗时任务2。。。。
耗时任务1。。。。
耗时任务2。。。。
耗时任务1。。。。
耗时任务2。。。。
耗时任务1。。。。
耗时任务2。。。。
耗时任务1。。。。
耗时任务2。。。。
耗时任务1。。。。
耗时任务2。。。。
耗时任务1。。。。
耗时任务2。。。。
耗时任务1。。。。
耗时任务2。。。。
不超时, 上面的两个任务都执行完
接下来的操作

作者：平凡之路561
链接：https://www.jianshu.com/p/8d4cc42b095b
来源：简书
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。