GCD并发async & sync

GCD并发async & sync

很多程序都有一个主线程,对于iOS/MacOS开发来说，这个线程就是UI线程，在这个线程上会做一些用户交互/渲染相关的事情。把过多的任务放在主线程，会导致主线程卡顿，进而用户看到的就是App响应慢，列表滚动的时候掉帧。把任务分散到多个线程执行有很多种技术，在iOS/MacOS App开发中，最简单直观的就是GCD（Grand Central Dispatch)，GCD是一个底层的C API。

对于使用GCD的开发者来说是没有线程的概念的，只有派发队列dispatch queue。任务都是以block的方式提交到对列上，然后GCD会自动的根据CPU的使用情况，创建线程池来执行任务，并且自动的运行到多核上；开发者没法参与queue的管理，队列采用FIFO模式（先进先出），意味着先加入的会被先执行，队列有两种：

1. 串行队列（serial queues）：不管调用的是async还是sync，任务都是做完一个才到下一个，顺序执行。
   
2. 并发队列（concurrent queues）：任务是并发一起执行。
   
3. async：提交一段任务到队列，立刻返回，不会阻塞当前线程。
   
4. sync：提交一段任务到队列，会阻塞当前线程，直到任务结束后，当前线程才可以继续执行。

系统缺省默认会为每个应用提供5个队列：1个串行主队列和4个并发全局队列。

Main Dispatch Queue（主队列）：对应主线程，是全局可用的串行队列，在应用的主线程中执行任务，这个队列一般被用来更新 App 的 UI。

除主队列之外系统默认还提供4个并发队列Global Dispatch Queue(全局队列)。这些队列对整个应用来说是全局可用的，彼此只有优先级高低的区别。要使用其中一个全局并发队列的话，你得使用dispatch_get_global_queue函数获得一个你想要的队列的引用，该函数的第一个参数取如下值：下面的这些优先级在Swift3.0中已经被废弃，已经用QOS来代替

DISPATCH_QUEUE_PRIORITY_HIGH
DISPATCH_QUEUE_PRIORITY_DEFAULT
DISPATCH_QUEUE_PRIORITY_LOW
DISPATCH_QUEUE_PRIORITY_BACKGROUND

这些队列类型代表着执行优先级。带有 HIGH 的队列有最高优先级，BACKGROUND 则是最低的优先级。这样你就能基于任务的优先级来决定要用哪一个队列。还要注意这些队列也被 Apple 的 API 所使用，所以这些队列中并不只有你自己的任务。

最后，除了这5个系统默认提供的队列，你也可以自己创建任何数量的串行或并发队列。使用并发队列的情况下，即使你可以自己创建，我还是强烈建议你使用上面那四个全局队列。

QOS

在使用GCD和DispatchQueues的时候我们经常需要告知操作系统,App里的哪些任务比其他任务更重要，哪些优先级更高。确定任务重要和优先级的属性被称为GCD服务等级(GCD QoS)。QoS是个枚举类型，在初始队列时，可以提供合适的QoS参数来得到相应的权限，如果没有指定QoS，那么初始方法会使用队列提供的默认QoS值default。 系统提供了5个优先级，从上到下优先级依次降低：

userInteractive: 和用户交互相关，比如动画等等优先级最高。 比如用户连续拖拽的计算

userInitiated: 需要立刻的结果， 比如push一个ViewController之前的数据计算

default: 获取全局队列Global Dispatch Queue时，如果不明确指定优先级，返回的就是这个优先级的全局队列。

utility: 可以执行很长时间，再通知用户结果。 比如下载一个文件，给用户下载进度 。

background: 用户不可见，比 如在后台存储大量数据

Swift3.0获取主队列、全局队列

let mainQueue = DispatchQueue.main  // 获取主队列，主线程。
let globalQueue = DispatchQueue.global() //获取全局队列，默认是default优先级
let globalQueueWithQos = DispatchQueue.global(qos: .userInitiated) 

Swfit3.0创建串行、并发队列

let serialQueue = DispatchQueue(label: "com.leo.serialQueue") //默认创建的是串行队列
let concurrentQueue = DispatchQueue(label: "com.leo.concurrentQueue",
                            attributes:.concurrent)  //明确指明需要创建并发队列。

串行队列的async

如果代码运行在Playground里，记得在顶部加上这两行。

 import PlaygroundSupport
 PlaygroundPage.current.needsIndefiniteExecution = true
 

public func readDataTask(label:String){
    print("Start task %@", label)
    sleep(3)
    print("  End task %@", label)
}

let serialQueue = DispatchQueue(label: "com.leo.serialQueue")

print("Main queue Start")
serialQueue.async { readDataTask(label: "1")    }  //async立刻返回
serialQueue.async { readDataTask(label: "2")    }  //async立刻返回
print("Main queue End")

--- output
Main queue Start
Main queue End
2017-03-31 11:59:38.386 MyPlayground[15660:3218113] Start task 1
2017-03-31 11:59:40.397 MyPlayground[15660:3218113] End task 1
2017-03-31 11:59:40.398 MyPlayground[15660:3218113] Start task 2
2017-03-31 11:59:42.399 MyPlayground[15660:3218113] End task 2

async提交一段任务到队列，立刻返回， 当前线程不会被async阻塞。所以Main queue End马上就打印出来了。

由于是串行队列，所以即使调用的是async, 任务还是做完一个才到下一个，顺序执行

串行队列的sync

public func readDataTask(label:String){
    print("Start task %@", label)
    sleep(3)
    print("  End task %@", label)
}

let serialQueue = DispatchQueue(label: "com.leo.serialQueue")

print("Main queue Start")
serialQueue.sync { readDataTask(label: "1")    } //sync阻塞了当前线程，直到任务完成才返回
serialQueue.sync { readDataTask(label: "2")    } //sync阻塞了当前线程，直到任务完成才返回

print("Main queue End")

--- output
Main queue Start
2017-03-31 12:30:54.915 MyPlayground[16030:3294545] Start task 1
2017-03-31 12:30:57.917 MyPlayground[16030:3294545]   End task 1
2017-03-31 12:30:57.918 MyPlayground[16030:3294545] Start task 2
2017-03-31 12:31:00.919 MyPlayground[16030:3294545]   End task 2
Main queue End

sync阻塞了当前线程，直到任务完成才返回。所以Main queue End要等到前面2个任务都执行完了，才打印出来。

由于是串行队列， 任务做完一个才到下一个，是顺序执行。

并发队列async

public func readDataTask(label:String){
    print("Start task %@", label)
    sleep(3)
    print("  End task %@", label)
}

let concurrentQueue = DispatchQueue(label: "com.leo.concurrentQueue",
                                    attributes: .concurrent) //并发队列

print("Main queue Start")
concurrentQueue.async { readDataTask(label: "1")    }
concurrentQueue.async { readDataTask(label: "2")    }
print("Main queue End")

--- output
Main queue Start
Main queue End
2017-03-31 14:23:33.705 MyPlayground[16602:3412412] Start task 2
2017-03-31 14:23:33.705 MyPlayground[16602:3412397] Start task 1
2017-03-31 14:23:36.709 MyPlayground[16602:3412397]   End task 1
2017-03-31 14:23:36.709 MyPlayground[16602:3412412]   End task 2

async提交一段任务到队列，立刻返回， 当前线程不会被async阻塞。所以Main queue End马上就打印出来了。

由于是并发队列, 任务是并发一起执行。

并发队列sync 感觉运行结果和 串行队列的sync 的一样

public func readDataTask(label:String){
    print("Start task %@", label)
    sleep(3)
    print("  End task %@", label)
}

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

print("Main queue Start")
concurrentQueue.sync { readDataTask(label: "1")    }
concurrentQueue.sync { readDataTask(label: "2")    }
print("Main queue End")

--- output
Main queue Start
2017-03-31 15:48:39.672 MyPlayground[17360:3609929] Start task 1
2017-03-31 15:48:42.673 MyPlayground[17360:3609929]   End task 1
2017-03-31 15:48:42.674 MyPlayground[17360:3609929] Start task 2
2017-03-31 15:48:45.675 MyPlayground[17360:3609929]   End task 2
Main queue End

sync阻塞了当前线程，直到任务完成才返回。所以Main queue End要等到前面2个任务都执行完了，才打印出来。

虽然是并发队列, 但调用的是sync方法，阻塞了当前线程，任务并不能并发执行。运行结果和 串行队列的sync 的一样