Swift--GCD的使用

DispatchQueue

DispatchQueue是一个类似线程的概念，这里称作对列队列是一个FIFO数据结构，意味着先提交到队列的任务会先开始执行）。DispatchQueue背后是一个由系统管理的线程池。

let queue = DispatchQueue(label: "com.Leo.demoQueue")
let qos =  DispatchQoS.default
let attributes = DispatchQueue.Attributes.concurrent
let autoreleaseFrequency = DispatchQueue.AutoreleaseFrequency.never
let queue = DispatchQueue(label: label, qos: qos, attributes: attributes, 
autoreleaseFrequency: autoreleaseFrequency, target: nil)

• label 队列的标识符，方便调试
• qos 队列的quality of service。用来指明队列的“重要性”。
• attributes 队列的属性。类型是DispatchQueue.Attributes,是一个结构体，遵循了协议OptionSet。意味着你可以这样传入第一个参数[.option1,.option2]
• autoreleaseFrequency。顾名思义，自动释放频率。有些队列是会在执行完任务后自动释放的，有些比如Timer等是不会自动释放的，是需要手动释放。

队列分类

1. 从创建者来讲，队列可以分为两种，其中系统创建的队列又分为两种以及主队列/全局队列获取方法

• 主队列(对应主线程)
• 全局队列

let mainQueue = DispatchQueue.main
let globalQueue = DispatchQueue.global()
let globalQueueWithQos = DispatchQueue.global(qos: .userInitiated)

2. 从任务的执行情况来讲，可以分为

• 串行(serial)
• 并行(concurrent)
  创建一个串行/并行队列

let serialQueue = DispatchQueue(label: "com.leo.serialQueue")
let concurrentQueue =
 DispatchQueue(label: "com.leo.concurrentQueue",attributes:.concurrent)

async

async 提交一段任务到队列，并且立刻返回
我们新建一个方法来模拟一段很长时间的任务，比如读一张很大的图

public func readDataTask(label:String){
    NSLog("Start sync task%@",label)
    sleep(2)
    NSLog("End sync task%@",label)
}

Tips：如果代码运行在Playground里，记得在最上面加上这两行。
import PlaygroundSupport
PlaygroundPage.current.needsIndefiniteExecution = true

然后，我们来看看在serial和concurrent队列上，任务的执行情况。

let serialQueue = DispatchQueue(label: "com.leo.serialQueue")
print("Main queue Start")
serialQueue.async {
    readDataTask(label: "1")
}
serialQueue.async {
    readDataTask(label: "2")
}
print("Main queue End")

打印结果：
Main queue Start
Main queue End
2017-01-04 22:51:40.909 GCD[28376:888938] Start task: 1
2017-01-04 22:51:42.979 GCD[28376:888938] End task: 1
2017-01-04 22:51:42.980 GCD[28376:888938] Start task: 2
2017-01-04 22:51:45.051 GCD[28376:888938] End task: 2

再来看看concurrent队列

print("Main queue Start")
let concurrentQueue = DispatchQueue(label: 
"com.leo.concurrent", attributes: .concurrent)
concurrentQueue.async {
    readDataTask(label: "3")
}
concurrentQueue.async {
    readDataTask(label: "4")
}
print("Main queue End")

打印结果：
Main queue Start
Main queue End
2017-01-04 23:06:36.659 GCD[28642:902085] Start task: 3
2017-01-04 23:06:36.659 GCD[28642:902070] Start task: 4
2017-01-04 23:06:38.660 GCD[28642:902085] End task: 3
2017-01-04 23:06:38.668 GCD[28642:902070] End task: 4

async

async 提交一段任务到队列，并且阻塞当前线程，任务结束后当前线程继续执行

let serialQueue = DispatchQueue(label: "com.leo.queue")
print("Main queue Start")
serialQueue.sync {
    readDataTask(label: "1")
}
print("Main queue End")
打印结果：
Main queue Start
2017-01-04 23:21:29.422 GCD[28796:912732] Start task: 1
2017-01-04 23:21:31.423 GCD[28796:912732] End task: 1
Main queue End

参考文章
GCD精讲（Swift 3&4）