GCD使用详解（Swift）

一、什么是GCD

GCD（Grand Central Dispatch）是苹果公司实现的一套先进先出执行的任务队列， 我们只要将程序闭包传给GCD， mac os会在系统线程池里执行该任务， 而且无法确定到底是哪个线程执行的。 总之， GCD是个顺序或并发执行队列， 封装了线程的调度， 开发者不用直接操作线程了。

DispatchQueue支持同步sync和异步async方法，每个人物即DispatchWorkItem只执行一遍； 同步和并发方法都是按照先进先出的顺序执行队列里的任务。

App进程在启动时系统会自动创建一个main queue即DispatchQueue.main， 注意该queue里不要执行耗时操作并只能在main队列里刷新界面。

一、DispatchQueue.main

静态变量main，即主线程；

二、DispatchQueue.global()

静态得到一个DispatchQueue但不是主线程，不能刷新UI；注意放开注释使用实例化queue和global的效果是一样的。

三、实例化时DispatchQueue的参数说明：

public convenience init(label: String, qos: DispatchQoS = default, attributes: DispatchQueue.Attributes = default, autoreleaseFrequency: DispatchQueue.AutoreleaseFrequency = default, target: DispatchQueue? = default)

label ： 队列的名称，方便调试。一般用 Bundle Identifier 类似的命名方式，将域名翻转，例如：com.xxx.xxx.queue。无默认值

qos ： Quality of Service(服务质量)。队列中在执行时是有优先级的，优先级越高的队列将获得更多的计算资源。优先级从高到底分为下面五种：

• userInteractive
• userInitiated
• default
• utility
• background

默认值为default

attributes：

• concurrent : 标识队列为并行队列

• initiallyInactive : 标识运行队列中的任务需要手动触发，由队列的 activate 方法进行触发。如果未添加此标识，向队列中添加的任务会自动运行。

默认为串行队列，若想为并行队列并且希望手动触发activate，则实例化时如下：

var queue: DispatchQueue = DispatchQueue.init(label: “com.xxx.xxx.queue”, attributes: [.concurrent, .initiallyInactive])

autoreleaseFrequency ：用来设置负责管理任务内对象生命周期的 autorelease pool 的自动释放频率。

包含三个类型：：

• inherit ： 继承目标队列的该属性
• workItem : 跟随每个任务的执行周期进行自动创建和释放
• never : 会自动创建 autorelease pool，需要手动管理。

一般采用 workItem 行了。如果任务内需要大量重复的创建对象，可以使用 never 类型，来手动创建 aotorelease pool。

target :

这个参数设置了队列的目标队列，即队列中的任务运行时实际所在的队列。目标队列最终约束了队列的优先级等属性。
在程序中手动创建的队列最后都指向了系统自带的主队列或全局并发队列。
那为什么不直接将任务添加到系统队列中，而是自定义队列呢？这样的好处是可以将任务分组管理。如单独阻塞某个队列中的任务，而不是阻塞系统队列中的全部任务。如果阻塞了系统队列，所有指向它的原队列也就被阻塞。
从 Swift 3 开始，对目标队列的设置进行了约束，只有两种情况可以显示的设置目标队列：
在初始化方法中设置目标队列；
在初始化方法中，attributes 设定为 initiallyInactive，在队列调用 activate() 之前，可以指定目标队列。
在其他地方都不能再改变目标队列

三、串行队列的特性：

1. 队列中如果没有任务在执行，那么提交同步任务后，将立即执行该任务，并阻塞线程 thread0，任务完成后再恢复线程 thread0 中被阻塞的任务。

2. 如果串行队列中有任务在执行，如果该任务又向该队列提交了一个同步任务，将会立即发生死锁。

3. 如果并行队列中有任务在执行，如果该任务又向该队列提交了一个同步任务，那么当前线程会转而执行新的同步任务，结束后再回到原任务。

4. 如果队列中有任务在执行，如果该任务向另一个队列提交了一个同步任务，那么当前线程会转而执行新的同步任务，结束后再回到原任务。

三、DispatchQueue基本用法异步async：

在子线程执行耗时操作完成后，将结果刷新到界面； 注意放开注释使用实例化queue和global的效果是一样的。

  let queue = DispatchQueue(label: "com.brycegao.gcdtest")
    queue.async {
        let date = Date()
        print("async1 \(date.description)")
        Thread.sleep(forTimeInterval: 1)   //停止1秒
    }
    queue.async {
        let date = Date()
        print("async2 \(date.description)")
        Thread.sleep(forTimeInterval: 1)
    }
    queue.async {
        let date = Date()
        print("async3 \(date.description)")
        Thread.sleep(forTimeInterval: 1)
    }  

从日志可以看出FIFO的特点，先添加的任务肯定先执行

async1 2016-12-27 13:47:38 +0000
async2 2016-12-27 13:47:39 +0000
async3 2016-12-27 13:47:40 +0000

四、DispatchQueue基本用法同步sync（相对于主线程）：

该方法会阻塞UI队列， 导致不显示控件或无点击事件等问题； sync方法仍然按照FIFO顺序执行。

    let queue = DispatchQueue(label: "com.brycegao.gcdtest")
    queue.async {  //异步方法不阻塞UI
        let date = Date()
        print("async1 \(date.description)")
        Thread.sleep(forTimeInterval: 1)   //停止1秒
    }
    queue.sync {   //同步方法会阻塞UI，造成不显示控件或无点击事件，但仍然是顺序执行
        let date = Date()
        print("sync \(date.description)")
        Thread.sleep(forTimeInterval: 10)
    }
    queue.async {
        let date = Date()
        print("async3 \(date.description)")
        Thread.sleep(forTimeInterval: 1)
    }  

async1 2016-12-27 13:55:17 +0000
sync 2016-12-27 13:55:18 +0000
async3 2016-12-27 13:55:28 +0000

五、上面介绍的是串行队列（默认）， 现在介绍并行队列。

并行对列只能通过实例化方式得到， 区别是有.concurrent参数。将上面的示例代码稍作改动， 即修改DispatchQueue的实例化方法参数。

 let conqueue = DispatchQueue(label: "queuename", attributes: .concurrent)  //并发队列
        
        conqueue.async {
            let date = Date()
            print("async1 \(date.description)")
            Thread.sleep(forTimeInterval: 1)   //停止1秒
        }
        conqueue.async {   //同步方法会阻塞UI，造成不显示控件或无点击事件，但仍然是顺序执行
            let date = Date()
            print("async2 \(date.description)")
            Thread.sleep(forTimeInterval: 1)
        }
        conqueue.async {
            let date = Date()
            print("async3 \(date.description)")
            Thread.sleep(forTimeInterval: 1)
        }        /*DispatchQueue.global().async 

async1 2016-12-27 14:08:21 +0000
async2 2016-12-27 14:08:21 +0000
async3 2016-12-27 14:08:21 +0000

六、asyncAfter

设置运行时间asyncAfter函数可以设置延迟一段时间后运行闭包，功能类似于定时器。 还是在上面示例代码上稍作修改。

.....
conqueue.async {
            let date = Date()
            print("async1 \(date.description)")
            Thread.sleep(forTimeInterval: 1)   //停止1秒
        }
        let time = DispatchTime.now() + 3
        conqueue.asyncAfter(deadline: time, execute: {
            let date = Date()
            print("asyncAfter \(date.description)")
        })
....

async1 2016-12-27 14:16:11 +0000
async3 2016-12-27 14:16:11 +0000
async2 2016-12-27 14:16:11 +0000
asyncAfter 2016-12-27 14:16:14 +0000

七 、DispatchGroup

DispatchGroup的作用就是监听一个或多个DispatchQueue任务结束的触发事件， 类似于Java的wait/notifyAll。

        let group = DispatchGroup()
        let queue1 = DispatchQueue(label: "queue1")
        queue1.async(group: group) {
            Thread.sleep(forTimeInterval: 1)   //停止1秒
            let date = Date()
            print("async1 \(date.description)")
        }
        let queue2 = DispatchQueue(label: "queue2")
        queue2.async(group: group) {
            Thread.sleep(forTimeInterval: 3)
            let date = Date()
            print("asycn2 \(date.description)")
        }
        let queue3 = DispatchQueue(label: "queue3")
        queue3.async(group: group){
            Thread.sleep(forTimeInterval: 1)
            let date = Date()
            print("async3 \(date.description)")
        }
        let date1 = Date()
        print("date1: \(date1.description)")
        group.wait()    //等待group的任务都执行完成后向下执行
        let date2 = Date()
        print("date2: \(date2.description)")

date1: 2016-12-27 14:32:52 +0000
async3 2016-12-27 14:32:53 +0000
async1 2016-12-27 14:32:53 +0000
asycn2 2016-12-27 14:32:55 +0000
date2: 2016-12-27 14:32:55 +0000

如上面示例代码， 将3个DispatchQueue的任务添加到DispatchGroup中， date1先打印出来， 等到async1、async2、async3都执行完成后才打印date2。