iOS 多线程记录（二）

前言

关于这篇文章的Demo能够去个人github中MultiThreadDemo查看源码，若有不当之处，但愿你们指出。git

这里是个人上一篇关于多线程的知识点记录 iOS 多线程记录（一）。程序员

GCD

介绍

GCD是苹果开发的多线程编程的解决方案，经过简单的API就能够实现建立新线程去执行咱们须要执行的任务，不须要咱们手动地建立和管理线程，只须要建立队列和相应的函数配合使用就行。github

优势

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

核心概念

• 队列

这里的队列指执行任务的等待队列，即用来存听任务的队列。队列是一种特殊的线性表，采用 FIFO（先进先出）的原则，即新任务老是被插入到队列的末尾，而读取任务的时候老是从队列的头部开始读取。每读取一个任务，则从队列中释放一个任务。编程

在 GCD 中有两种队列：串行队列和并发队列。二者的主要区别是：执行顺序不一样，以及开启线程数不一样。bash

• 串行队列网络

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

• 并发队列多线程

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

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

• 任务

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

• 同步执行（sync）
  • 同步添加任务到指定的队列中，会在前面的任务执行完成以后，再执行。
  • 只能在当前线程中执行任务，不具有开启新线程的能力。
• 异步执行（async）
  • 异步添加任务到指定的队列中，它不会作任何等待，能够直接执行任务。
  • 能够在新的线程中执行任务，具有开启新线程的能力。

基本使用

1. 建立一个队列
2. 在队列中添加任务

建立队列

• 获取主队列

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

• 获取全局队列

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

• 建立队列

1. 简单方式建立

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

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 只需两步，可是既然咱们有两种队列（串行队列/并发队列），两种任务执行方式（同步执行/异步执行），那么咱们就有了四种不一样的组合方式。再加上两种特殊队列：全局并发队列、主队列。全局并发队列能够做为普通并发队列来使用。可是主队列由于有点特殊，因此咱们就又多了两种组合方式。这样就有六种不一样的组合方式了。

1. 并发队列 + 同步执行
2. 并发队列 + 异步执行
3. 串行队列 + 同步执行
4. 串行队列 + 异步执行
5. 主队列 + 同步执行
6. 主队列 + 异步执行

各类组合的结果

区别	并发队列	串行队列	主队列
同步(sync)	没有开启新线程，串行执行任务	没有开启新线程，串行执行任务	会形成死锁
异步(async)	有开启新线程，并发执行任务	有开启新线程(1条)，串行执行任务	没有开启新线程，串行执行任务

并发队列 + 同步执行

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

-----输出结果：-----
sync1 + <NSThread: 0x600003bc35c0>{number = 1, name = main}
sync2 + <NSThread: 0x600003bc35c0>{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 + <NSThread: 0x60000018e540>{number = 3, name = (null)}
begin
async2 + <NSThread: 0x600000196600>{number = 4, name = (null)}
begin
async3 + <NSThread: 0x6000001bc900>{number = 5, name = (null)}
async5 + <NSThread: 0x600000196600>{number = 4, name = (null)}
async4 + <NSThread: 0x60000018e540>{number = 3, name = (null)}
复制代码

结论：

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

串行队列 + 同步执行

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

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

-----输出结果：-----
sync1 + <NSThread: 0x600000a968c0>{number = 1, name = main}
sync2 + <NSThread: 0x600000a968c0>{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 + <NSThread: 0x60000032b940>{number = 3, name = (null)}
begin
async2 + <NSThread: 0x60000032b940>{number = 3, name = (null)}
begin
async3 + <NSThread: 0x60000032b940>{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 + <NSThread: 0x600001af6880>{number = 1, name = main}
begin
async2 + <NSThread: 0x600001af6880>{number = 1, name = main}
begin
async3 + <NSThread: 0x600001af6880>{number = 1, name = main}
begin
async4 + <NSThread: 0x600001af6880>{number = 1, name = main}
begin
async5 + <NSThread: 0x600001af6880>{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 + <NSThread: 0x60000383d100>{number = 3, name = (null)}
async-end
main + <NSThread: 0x600003821680>{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 + <NSThread: 0x600000f9d800>{number = 3, name = (null)}
async3 + <NSThread: 0x600000f9da40>{number = 6, name = (null)}
async4 + <NSThread: 0x600000f9bac0>{number = 7, name = (null)}
async1 + <NSThread: 0x600000f9d800>{number = 3, name = (null)}
async2 + <NSThread: 0x600000fa4040>{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)
}

-----输出结果：-----
<NSThread: 0x60000193ce40>{number = 3, name = (null)}
<NSThread: 0x600001921100>{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

复制代码