iOS 多线程记录（二）

关于这篇文章的Demo可以去我的github中MultiThreadDemo查看源码，如有不当之处，希望大家指出。

这里是我的上一篇关于多线程的知识点记录多线程记录（二）

GCD

介绍
GCD是苹果开发的多线程编程的解决方案，通过简单的API就可以实现创建新线程去执行我们需要执行的任务，不需要我们手动地创建和管理线程，只需要创建队列和相应的函数配合使用就行。

优点
GCD 可用于多核的并行运算
GCD 会自动利用更多的 CPU 内核（比如双核、四核）
GCD 会自动管理线程的生命周期（创建线程、调度任务、销毁线程）
程序员只需要告诉 GCD 想要执行什么任务，不需要编写任何线程管理代码

核心概念

队列

这里的队列指执行任务的等待队列，即用来存放任务的队列。队列是一种特殊的线性表，采用 FIFO（先进先出）的原则，即新任务总是被插入到队列的末尾，而读取任务的时候总是从队列的头部开始读取。每读取一个任务，则从队列中释放一个任务。
在 GCD 中有两种队列：串行队列和并发队列。两者的主要区别是：执行顺序不同，以及开启线程数不同。

串行队列

每次只有一个任务被执行。让任务一个接着一个地执行。（只开启一个线程，一个任务执行完毕后，再执行下一个任务）

并发队列

可以让多个任务并发执行。（可以开启多个线程，并且同时执行任务）

并发队列 的并发功能只有在异步函数下才有效。

任务

就是我们需要执行的操作。执行任务有两种方式：同步执行（sync）和异步执行（async）。两者的主要区别是：是否等待队列的任务执行结束，以及是否具备开启新线程的能力。

同步执行（sync）

同步添加任务到指定的队列中，会在前面的任务执行完成之后，再执行。
只能在当前线程中执行任务，不具备开启新线程的能力。

异步执行（async）

异步添加任务到指定的队列中，它不会做任何等待，可以直接执行任务。
可以在新的线程中执行任务，具备开启新线程的能力。

基本使用

创建一个队列
在队列中添加任务

创建队列

获取主队列

// 获取主队列
let mainQueue = DispatchQueue.main
复制代码

获取全局队列

// 获取全局队列
let globalQueue = DispatchQueue.global()
复制代码

创建队列

1.简单方式创建

指定队列的名称，其它为默认项，这样的初始化的列队有着默认的配置项,默认的列队是串行列队。

let queue = DispatchQueue(label: "com.jiangT.queue")
复制代码

2.属性设置方式创建

let queue = DispatchQueue.init(label: "com.jiangT.queue",
                                qos: DispatchQoS.default,
                                attributes:DispatchQueue.Attributes.concurrent,
                                autoreleaseFrequency:DispatchQueue.AutoreleaseFrequency.inherit,
                                target: nil)

复制代码

参数介绍：

label： 队列的标识符，能够方便区分列队进行调试。
qos： 队列的优先级。

优先级由最低的background到最高的userInteractive共五个，还有一个为定义的unspecified.
background：最低优先级，等同于DISPATCH_QUEUE_PRIORITY_BACKGROUND.用户不可见，比如：在后台存储大量数据
utility：优先级等同于DISPATCH_QUEUE_PRIORITY_LOW，可以执行很长时间，再通知用户结果。比如：下载一个大文件，网络，计算
default：默认优先级,优先级等同于DISPATCH_QUEUE_PRIORITY_DEFAULT，建议大多数情况下使用默认优先级
userInitiated：优先级等同于DISPATCH_QUEUE_PRIORITY_HIGH,需要立刻的结果
.userInteractive：用户交互相关，为了好的用户体验，任务需要立马执行。使用该优先级用于UI更新，事件处理和小工作量任务，在主线程执行。
Qos指定了列队工作的优先级，系统会根据优先级来调度工作，越高的优先级能够越快被执行，但是也会消耗功能，所以准确的指定优先级能够保证app有效的使用资源。

attributes： 队列的属性，可以指定并发还是串行。
autoreleaseFrequency： 自动释放频率，有些列队会在执行完任务之后自动释放，有些是不会自动释放的，需要手动释放。

添加任务

同步任务

let globalQueue = DispatchQueue.global()

globalQueue.sync {
    print("sync + \(Thread.current)")
}
复制代码

异步任务

let globalQueue = DispatchQueue.global()

globalQueue.async {
    print("async + \(Thread.current)")
}
复制代码

虽然使用 GCD 只需两步，但是既然我们有两种队列（串行队列/并发队列），两种任务执行方式（同步执行/异步执行），那么我们就有了四种不同的组合方式。再加上两种特殊队列：全局并发队列、主队列。全局并发队列可以作为普通并发队列来使用。但是主队列因为有点特殊，所以我们就又多了两种组合方式。这样就有六种不同的组合方式了。

并发队列 + 同步执行
并发队列 + 异步执行
串行队列 + 同步执行
串行队列 + 异步执行
主队列 + 同步执行
主队列 + 异步执行

各种组合的结果

在这里插入图片描述

并发队列 + 同步执行

DispatchQueue.global().sync {
    print("sync1 + \(Thread.current)")
}
DispatchQueue.global().sync {
    print("sync2 + \(Thread.current)")
}

-----输出结果：-----
sync1 + {number = 1, name = main}
sync2 + {number = 1, name = main}

结论：

所有任务都是在当前线程（主线程）中执行的，没有开启新的线程（同步执行不具备开启新线程的能力）。
任务按顺序执行的。按顺序执行的原因：虽然并发队列可以开启多个线程，并且同时执行多个任务。但是同步任务不具备开启新线程的能力，所以也就不存在并发。而且当前线程只有等待当前队列中正在执行的任务执行完毕之后，才能继续接着执行下面的操作（同步任务需要等待队列的任务执行结束）。所以任务只能一个接一个按顺序执行，不能同时被执行。

并发队列 + 异步执行

DispatchQueue.global().async {
    print("begin")
    print("async1 + \(Thread.current)")
}
DispatchQueue.global().async {
    print("begin")
    print("async2 + \(Thread.current)")
}
DispatchQueue.global().async {
    print("begin")
    print("async3 + \(Thread.current)")
}
DispatchQueue.global().async {
    print("begin")
    print("async4 + \(Thread.current)")
}
DispatchQueue.global().async {
    print("begin")
    print("async5 + \(Thread.current)")
}

-----输出结果：-----
begin
begin
begin
async1 + {number = 3, name = (null)}
begin
async2 + {number = 4, name = (null)}
begin
async3 + {number = 5, name = (null)}
async5 + {number = 4, name = (null)}
async4 + {number = 3, name = (null)}
复制代码

结论：

除了当前线程（主线程），系统又开启了3个线程，并且任务是交替/同时执行的。（异步执行具备开启新线程的能力。且并发队列可开启多个线程，同时执行多个任务）。

串行队列 + 同步执行

let queue = DispatchQueue.init(label: "")

queue.sync {
    print("sync1 + \(Thread.current)")
}
queue.sync {
    print("sync1 + \(Thread.current)")
}

-----输出结果：-----
sync1 + {number = 1, name = main}
sync2 + {number = 1, name = main}

复制代码

结论：

所有任务都是在当前线程（主线程）中执行的，并没有开启新的线程（同步执行不具备开启新线程的能力）。
任务是按顺序执行的（串行队列每次只有一个任务被执行，任务一个接一个按顺序执行）。

串行队列 + 异步执行

let queue = DispatchQueue.init(label: "")

queue.async {
    print("begin")
    print("async1 + \(Thread.current)")
}
queue.async {
    print("begin")
    print("async2 + \(Thread.current)")
}
queue.async {
    print("begin")
    print("async3 + \(Thread.current)")
}

-----输出结果：-----
begin
async1 + {number = 3, name = (null)}
begin
async2 + {number = 3, name = (null)}
begin
async3 + {number = 3, name = (null)}
复制代码

结论：

开启了一条新线程（异步执行具备开启新线程的能力，串行队列只开启一个线程）。
任务是按顺序执行的（串行队列每次只有一个任务被执行，任务一个接一个按顺序执行）。

主队列 + 同步执行

主队列：GCD自带的一种特殊的串行队列

// 主线程执行同步任务
func syncMain() {
    print("方法开始")   // 调用方法后，可以看到这个输出
    DispatchQueue.main.sync {
        print("会造成死锁")
    }
}

-----输出结果：-----
方法开始

结论：

1.当把任务放进主队列时，它需要等待主队列执行完当前任务后执行。
2.主线程现在正在处理 syncMain 方法，任务需要等 syncMain 执行完才能执行。
3.syncMain 在执行时，又要等任务执行完才能完成方法。
4.这样 syncMain 方法和任务就开始了互相等待，形成了死锁。

主队列 + 异步执行

DispatchQueue.main.async {
    print("begin")
    print("async1 + \(Thread.current)")
}
DispatchQueue.main.async {
    print("begin")
    print("async2 + \(Thread.current)")
}
DispatchQueue.main.async {
    print("begin")
    print("async3 + \(Thread.current)")
}
DispatchQueue.main.async {
    print("begin")
    print("async4 + \(Thread.current)")
}
DispatchQueue.main.async {
    print("begin")
    print("async5 + \(Thread.current)")
}

-----输出结果：-----
begin
async1 + {number = 1, name = main}
begin
async2 + {number = 1, name = main}
begin
async3 + {number = 1, name = main}
begin
async4 + {number = 1, name = main}
begin
async5 + {number = 1, name = main}
复制代码

结论：

所有任务都是在当前线程（主线程）中执行的，并没有开启新的线程（虽然异步执行具备开启线程的能力，但因为是主队列，所以所有任务都在主线程中）。
任务是按顺序执行的（因为主队列是串行队列，每次只有一个任务被执行，任务一个接一个按顺序执行）。

线程间通信

/**
 * 线程间通信
 */
DispatchQueue.global().async {
    print("async-begin")
    print("global + \(Thread.current)")
    print("async-end")

    let testNum = 666

    // 回到主线程
    DispatchQueue.main.async {
        print("main + \(Thread.current)")
        print("pass testNum: \(testNum)")
    }
}
-----输出结果：-----
async-begin
global + {number = 3, name = (null)}
async-end
main + {number = 1, name = main}
pass testNum: 666
复制代码

结论：

可以看到在全局线程中先执行任务，执行完了之后回到主线程执行主线程的相应操作并将全局线程的testNum接收到。

DispatchWorkItem
DispatchWorkItem是用于帮助DispatchQueue来执行列队中的任务。
一般情况下，我们开启一个异步线程，会这样创建列队并执行async方法，以闭包的方式提交任务。

DispatchQueue.global().async {
    // do async task
}
复制代码

使用了DispatchWorkItem类将任务封装成为对象，由对象进行任务。

let item = DispatchWorkItem {
      // do task
 }
 DispatchQueue.global().async(execute: item)
复制代码

也可以使用DispatchWorkItem实例对象的perform方法执行任务

let workItem = DispatchWorkItem {
     // do task
 }
 DispatchQueue.global().async {
    workItem.perform()
 }
复制代码```

**栅栏方法**
我们有时需要异步执行两组操作，而且第一组操作执行完之后，才能开始执行第二组操作。这样我们就需要一个相当于 栅栏 一样的一个方法将两组异步执行的操作组给分割起来，当然这里的操作组里可以包含一个或多个任务。
栅栏 会等待前边追加到并发队列中的任务全部执行完毕之后，再将指定的任务追加到该异步队列中。

```let dataQueue = DispatchQueue(label: "com.jiangT.queue", attributes: .concurrent)

let item = DispatchWorkItem(qos: .default, flags: .barrier) {
    print("barrier + \(Thread.current)")
    dataQueue.async {
        print("async1 + \(Thread.current)")
    }
    dataQueue.async {
        print("async2 + \(Thread.current)")
    }
}

dataQueue.async(execute: item)
dataQueue.async {
    print("async3 + \(Thread.current)")
}
dataQueue.async {
    print("async4 + \(Thread.current)")
}

-----输出结果：-----
barrier + {number = 3, name = (null)}
async3 + {number = 6, name = (null)}
async4 + {number = 7, name = (null)}
async1 + {number = 3, name = (null)}
async2 + {number = 8, name = (null)}
复制代码

执行任务结束通过nofify获得通知

let workItem = DispatchWorkItem {
    // do async task
    print(Thread.current)
}
DispatchQueue.global().async {
    workItem.perform()
}
workItem.notify(queue: DispatchQueue.main) {
    // update UI
    print(Thread.current)
}

-----输出结果：-----
{number = 3, name = (null)}
{number = 1, name = main}
复制代码

使用wait等待任务执行完成

let queue = DispatchQueue(label: "queue", attributes: .concurrent)
let workItem = DispatchWorkItem {
    sleep(5)
    print("done")
}

queue.async(execute: workItem)
print("before waiting")
workItem.wait()
print("after waiting")

-----输出结果：-----
before waiting
done
after waiting
复制代码

延迟执行方法

let delay = DispatchTime.now() + DispatchTimeInterval.seconds(10)
 DispatchQueue.main.asyncAfter(deadline: delay) {
     // 延迟执行
 }

 可以简化为：

 let delay = DispatchTime.now() + 10
 DispatchQueue.main.asyncAfter(deadline: delay) {
     // 延迟执行
 }

复制代码其它的延时执行方法：

func asyncAfter(deadline: DispatchTime, execute: DispatchWorkItem)
func asyncAfter(deadline: DispatchTime, qos: DispatchQoS, flags: DispatchWorkItemFlags, execute: () -> Void)

func asyncAfter(wallDeadline: DispatchWallTime, execute: DispatchWorkItem)
func asyncAfter(wallDeadline: DispatchWallTime, qos: DispatchQoS, flags: DispatchWorkItemFlags, execute: () -> Void)

快速迭代方法
之前使用GCD的dispatch_apply()执行多次任务，现在是调用concurrentPerform(),下面是并发执行5次

DispatchQueue.concurrentPerform(iterations: 5) {
    print("\($0)")
}

-----输出结果：-----
2
0
1
3
4

队列组操作
有时候我们会有这样的需求：分别异步执行2个耗时任务，然后当2个耗时任务都执行完毕后再回到主线程执行任务。这时候我们可以用到 GCD 的队列组。

let queue = DispatchQueue.global()
let group = DispatchGroup()

group.enter()
queue.async(group: group) {
    DispatchQueue.main.asyncAfter(deadline: .now() + 2, execute: {
        print("Task one finished")
        group.leave()
    })
}
group.enter()
queue.async(group: group) {
    print("Task two finished")
    group.leave()
}
group.enter()
queue.async(group: group) {
    print("Task three finished")
    group.leave()
}
group.notify(queue: queue) {
    print("All task has finished")
}

----输出结果：-----
Task two finished
Task three finished
Task one finished
All task has finished