阅读 315

iOS 多线程记录(二)

前言

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

这里是我的上一篇关于多线程的知识点记录 iOS 多线程记录(一)

GCD

介绍

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

优点

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

核心概念

  • 队列

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

在 GCD 中有两种队列:串行队列和并发队列。两者的主要区别是:执行顺序不同,以及开启线程数不同

  • 串行队列

    • 每次只有一个任务被执行。让任务一个接着一个地执行。(只开启一个线程,一个任务执行完毕后,再执行下一个任务)
  • 并发队列

    • 可以让多个任务并发执行。(可以开启多个线程,并且同时执行任务)

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

  • 任务

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

  • 同步执行(sync)
    • 同步添加任务到指定的队列中,会在前面的任务执行完成之后,再执行。
    • 只能在当前线程中执行任务,不具备开启新线程的能力。
  • 异步执行(async)
    • 异步添加任务到指定的队列中,它不会做任何等待,可以直接执行任务。
    • 可以在新的线程中执行任务,具备开启新线程的能力。

基本使用

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

创建队列

  • 获取主队列
// 获取主队列
let mainQueue = DispatchQueue.main
复制代码
  • 获取全局队列
// 获取全局队列
let globalQueue = DispatchQueue.global()
复制代码
  • 创建队列
  1. 简单方式创建

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

let queue = DispatchQueue(label: "com.jiangT.queue")
复制代码
  1. 属性设置方式创建
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

复制代码
关注下面的标签,发现更多相似文章
评论