iOS 多线程实现——Grand Central Dispatch（GCD）

一、前言

GCD是Apple开发的一个多核编程的解决方法，基本概念就是dispatch queue（调度队列），queue是一个对象，它可以接受任务，并将任务以先到先执行的顺序来执行。dispatch queue可以是并发的或串行的。

1.同步和异步

那在 GCD 中，它们的参照对象就是我们的主线程 ( dispatchQueue.main ) 。也就是说如果是同步任务，那就在主线程执行；而如果是异步任务，那就在其他线程执行。

本文中出现的 “任务” 是指 sync {} 和 async {} 中整个代码块的统称

2.串行和并发队列

在 GCD 中，任务由队列 (串行或并发) 负责管理和决定其执行顺序，在一条由系统自动分配的线程上执行。

在串行 (Serial) 队列中执行任务时，任务会按照固定顺序执行，执行完一个任务后再继续执行下一个任务 (这意味着串行队列同时只能执行一个任务) ；在并发 (Concurrent) 队列中执行任务时，任务可以同时执行 ( 其实是在以极短的时间内不断的切换线程执行任务 ) 。

3.主线程和主队列

当应用程序启动时，就有一条线程被系统创建，与此同时这条线程也会立刻运行，该线程通常叫做程序的主线程。

同时系统也为我们提供一个名为主队列 ( DispatchQueue.main {} ) 的串行特殊队列，默认我们写的代码都处于主队列中，主队列中的所有任务都在主线程执行。

二、基本使用

1、创建队列

1.1 创建自定义队列

//创建串行队列
let serial = DispatchQueue(label: "serialQueue1")
 
//创建并行队列
let concurrent = DispatchQueue(label: "concurrentQueue1", attributes: .concurrent)

第一个参数代表队列的名称，可以任意起名
第二个参数代表队列属于串行还是并行执行任务
串行队列一次只执行一个任务。一般用于按顺序同步访问，但我们可以创建任意数量的串行队列，各个串行队列之间是并发的。
并行队列的执行顺序与其加入队列的顺序相同。可以并发执行多个任务，但是执行完成的顺序是随机的。

1.2 获取系统存在的全局队列

let globalQueue = DispatchQueue.global(qos: .default)

Global Dispatch Queue有4个执行优先级：
.userInitiated 高
.default 正常
.utility 低
.background 非常低的优先级（这个优先级只用于不太关心完成时间的真正的后台任务）

1.3 获取系统主队列

let mainQueue = DispatchQueue.main

2.添加任务到队列

2.1 async异步追加Block块

不需要等待

DispatchQueue.global(qos: .default).async {
    //处理耗时操作的代码块...
    print("do work")
     
    //操作完成，调用主线程来刷新界面
    DispatchQueue.main.async {
        print("main refresh")
    }
}

2.2 sync同步追加Block块

同步追加Block块，与上面相反。在追加Block结束之前，sync函数会一直等待，等待队列前面的所有任务完成后才能执行追加的任务。

//添加同步代码块到global队列
//不会造成死锁，但会一直等待代码块执行完毕
DispatchQueue.global(qos: .default).sync {
    print("sync1")
}
print("end1")
 
 
//添加同步代码块到main队列会引起死锁
//因为在主线程里面添加一个任务，因为是同步，所以要等添加的任务执行完毕后才能继续走下去。但是新添加的任务排在/队列的末尾，要执行完成必须等前面的任务执行完成，由此又回到了第一步，程序卡死
DispatchQueue.main.sync {
    print("sync2")
}
print("end2")

3.asyncAfter 延迟调用

asyncAfter 并不是在指定时间后执行任务处理，而是在指定时间后把任务追加到queue里面。因此会有少许延迟。注意，我们不能直接取消我们已经提交到 asyncAfter 里的代码。

//延时2秒执行
DispatchQueue.global(qos: .default).asyncAfter(deadline: DispatchTime.now() + 2.0) {
    print("after!")
}

如果需要取消正在等待执行的Block操作，我们可以先将这个Block封装到DispatchWorkItem对象中，然后对其发送cancle，来取消一个正在等待执行的block。

//将要执行的操作封装到DispatchWorkItem中
let task = DispatchWorkItem { print("after!") }
//延时2秒执行
DispatchQueue.main.asyncAfter(deadline: DispatchTime.now() + 2, execute: task)
//取消任务
task.cancel()

4.暂停或者继续队列

//创建并行队列
let conQueue = DispatchQueue(label: "concurrentQueue1", attributes: .concurrent)
//暂停一个队列
conQueue.suspend()
//继续队列
conQueue.resume()

suspend()后，追加到Dispatch Queue中尚未执行的任务在此之后停止执行。
resume()则使得这些任务能够继续执行。

5.多个任务全部结束后做一个全部结束的处理

//获取系统存在的全局队列
let queue = DispatchQueue.global(qos: .default)
//定义一个group
let group = DispatchGroup()
//并发任务，顺序执行
queue.async(group: group) {
    sleep(2)
    print("block1")
}
queue.async(group: group) {
    print("block2")
}
queue.async(group: group) {
    print("block3")
}
 
//1,所有任务执行结束汇总，不阻塞当前线程
group.notify(queue: .global(), execute: {
    print("group done")
})
 
//2,永久等待，直到所有任务执行结束，中途不能取消，阻塞当前线程
group.wait()
print("任务全部执行完成")

async(group:)：用来监视一组block对象的完成，你可以同步或异步地监视
notify()：用来汇总结果，所有任务结束汇总，不阻塞当前线程
wait()：等待直到所有任务执行结束，中途不能取消，阻塞当前线程

6.concurrentPerform 指定次数的Block最加到队列中

如果需要多次并发执行相同的闭包，可以使用concurrentPerform(iterations:execute:) 方法。DispatchQueue.concurrentPerform函数是sync函数和Dispatch Group的关联API。按指定的次数将指定的Block追加到指定的Dispatch Queue中，并等待全部处理执行结束。
因为concurrentPerform函数也与sync函数一样，会等待处理结束，因此推荐在async函数中异步执行concurrentPerform函数。concurrentPerform函数可以实现高性能的循环迭代。

//获取系统存在的全局队列
let queue = DispatchQueue.global(qos: .default)
 
//定义一个异步步代码块
queue.async {
    //通过concurrentPerform，循环变量数组
    DispatchQueue.concurrentPerform(iterations: 6) {(index) -> Void in
        print(index)
    }  
    //执行完毕，主线程更新
    DispatchQueue.main.async {
        print("done")
    }
}

7.信号量

信号量就是控制访问资源的数量，比如系统有两个资源可以被利用，同时有三个线程要访问，只能允许两个线程访问，第三个应当等待资源被释放后再访问。

DispatchSemaphore(value: )：用于创建信号量，可以指定初始化信号量计数值。

let semaphore = DispatchSemaphore(value: 2) //初始化信号量为2

semaphore.wait()：判断信号量，如果为小于2，则往下执行，信号量-1。如果是2，则等待。

semaphore.wait()

semaphore.signal()：代表运行结束，信号量加1，有等待的任务这个时候才会继续执行。

semaphore.signal()

//获取系统存在的全局队列
let queue = DispatchQueue.global(qos: .default)
 
//当并行执行的任务更新数据时，会产生数据不一样的情况
for i in 1...10 {
    queue.async {
        print("\(i)")
    }
}
 
//使用信号量保证正确性
//创建一个初始计数值为2的信号
let semaphore = DispatchSemaphore(value: 2)
for i in 1...10 {
    queue.async {
        //永久等待，直到Dispatch Semaphore的计数值 >= 2
        semaphore.wait()
        print("\(i)")
        //发信号，使原来的信号计数值+1
        semaphore.signal()
    }
}