调度工作项

调度工作项：其实就是一项任务，可以把你想要执行的代码写成闭包，在DispatchWorkItem初始化时传进去，方便后续管理任务，并且会让代码更整洁。串行：在本文中指串行队列，多个任务放在串行队列里执行，只能按顺序依次运行，前一个运行完成，下一个才能开始运行；前一个没运行完，后一个只能排队等着。以此类推，直到所有任务都运行完成。
并行：在本文中指并行队列，多个任务放在并行队列里执行，可以同时运行。
2. DispatchWorkItem

官网原文：The work you want to perform, encapsulated in a way that lets you attach a completion handle or execution dependencies.

同步：在本文中指同步执行任务，是在一个线程里按顺序执行多项任务，执行结束的顺序是固定的、和任务的执行顺序相同。总耗时是所有任务耗时之和。
异步：在本文中指异步执行任务，也是按顺序执行多项任务，但是是放在多个线程里同时运行，执行结束的顺序是随机的、不可预估的。总耗时大约是耗时最长的那项任务所消耗的时间。调度工作项初始化，正常情况下，使用第一种方式即可（特殊情况后续会再讲解）：

Main queue
Global queue
Custom queue
3.1 Main queue(主队列，串行)
Main queue与主线程关联的调度队列，是一种串行队列（Serial），与UI相关的操作必须放在Main queue中执行，获取方式是：

let mainQueue = DispatchQueue.main
3.2 Global queue(全局队列，并行)
Global queue运行在后台线程，是系统内共享的全局队列，是一种并行队列（Concurrent），用于处理并发任务，获取方式是：
//1. 只带尾随闭包
let item1 = DispatchWorkItem {
print(“item1”)
}

//2. 指定qos（执行优先级）或flags（特殊行为标记）
let item2 = DispatchWorkItem(qos: .userInteractive, flags: .barrier) {
print(“item2”)
}
3. DispatchQueue简介
调度队列：一个对象，用来管理任务在app的主线程或后台线程串行或并行执行。
官网原文：An object that manages the execution of tasks serially or concurrently on your app’s main thread or on a background thread.

DispatchQueue有三种类型:
let globalQueue = DispatchQueue.global()
3.3 Custom queue(自定义队列，默认串行)
Custom queue运行在后台线程，默认是串行队列（Serial），初始化时指定attributes参数为 .concurrent，可以创建成并行队列（Concurrent），创建方式如下：

//串行队列，label名字随便取
let serialQueue = DispatchQueue(label: “test”)

//并行队列
let concurrentQueue = DispatchQueue(label: “test”, attributes: .concurrent)
4. DispatchGroup简介
调度组：一个小组，你可以把多项任务放到一个组里，方便进行统一管理（直译过来并不好理解）。
官网原文：A group of tasks that you monitor as a single unit.

DispatchGroup可以很方便的管理多项任务。比如当同一组里的所有事件都完成后，GCD API可以发送通知，执行相应的操作。常用方法:

notify()：调度组里的所有任务执行完毕，会在此收到通知，不会阻塞当前线程。
wait()：一直等待，直到调度组里所有任务都执行完毕或等待超时，阻塞当前线程。
第二部分：实战篇
5. 使用DispatchQueue
新建Playground项目，定义四个调度任务，提供给下文调用，可大幅降低下文代码量，部分运行结果请自己复制代码多次运行感受，我只讲结果：
//自定义并行队列追加同步任务，按顺序打印
let concurrentQueue = DispatchQueue(label: “concurrent”, attributes: .concurrent)
concurrentQueue.sync(execute: item1)
concurrentQueue.sync(execute: item2)
concurrentQueue.sync(execute: item3)
concurrentQueue.sync(execute: item4)
注：在并行队列中执行同步任务，跟在串行队列中执行异步或同步任务，结果完全一样。 在主队列中不能混入同步任务，否则会引起死锁。
import Foundation

//定义四个调度任务，打印当前线程数据
let item1 = DispatchWorkItem {
for i in 0…4{
print(“item1 -> (i) thread: (Thread.current)”)
}
}

let item2 = DispatchWorkItem {
for i in 0…4{
print(“item2 -> (i) thread: (Thread.current)”)
}
}

let item3 = DispatchWorkItem {
for i in 0…4{
print(“item3 -> (i) thread: (Thread.current)”)
}
}

let item4 = DispatchWorkItem {
for i in 0…4{
print(“item4 -> (i) thread: (Thread.current)”)
}
}
5.1 异步执行
//主队列追加异步任务，按顺序打印
let mainQueue = DispatchQueue.main
mainQueue.async(execute: item1)
mainQueue.async(execute: item2)
mainQueue.async(execute: item3)
mainQueue.async(execute: item4)

//全局队列追加异步任务，随机打印
let globalQueue = DispatchQueue.global()
globalQueue.async(execute: item1)
globalQueue.async(execute: item2)
globalQueue.async(execute: item3)
globalQueue.async(execute: item4)

//自定义串行队列追加异步任务，按顺序打印
let serialQueue = DispatchQueue(label: “serial”)
serialQueue.async(execute: item1)
serialQueue.async(execute: item2)
serialQueue.async(execute: item3)
serialQueue.async(execute: item4)

//自定义并行队列追加异步任务，随机打印
let concurrentQueue = DispatchQueue(label: “concurrent”, attributes: .concurrent)
concurrentQueue.async(execute: item1)
concurrentQueue.async(execute: item2)
concurrentQueue.async(execute: item3)
concurrentQueue.async(execute: item4)
注：在串行队列中执行异步任务，结果跟执行同步任务完全一样

5.2 同步执行
//主队列追加同步任务，会引起死锁
let mainQueue = DispatchQueue.main
mainQueue.sync(execute: item1)
mainQueue.sync(execute: item2)
mainQueue.sync(execute: item3)
mainQueue.sync(execute: item4)

//全局队列追加同步任务，按顺序打印
let globalQueue = DispatchQueue.global()
globalQueue.sync(execute: item1)
globalQueue.sync(execute: item2)
globalQueue.sync(execute: item3)
globalQueue.sync(execute: item4)

//自定义串行队列追加同步任务，按顺序打印
let serialQueue = DispatchQueue(label: “serial”)
serialQueue.sync(execute: item1)
serialQueue.sync(execute: item2)
serialQueue.sync(execute: item3)
serialQueue.sync(execute: item4)