【iOS】Swift4.0 GCD的使用笔记

前言

在Swift4.0版本中GCD的常用方法还是有比较大的改动,这里做个简单的整理汇总。

GCD的队列

队列是一种遵循先进先出(FIFO)原则的数据结构,是一种特殊的线性表。

主队列 全局队列 串行队列 并行队列
同步 X 并行同步 串行同步
异步 串行异步 并行异步 串行异步

X 表示禁止这么使用,—— 表示不建议这么使用。

1. 主队列

主队列默认是串行的,另外主队列不能结合同步函数(sync)使用,会造成线程死锁。

override func viewDidLoad() {
      super.viewDidLoad()
      // Do any additional setup after loading the view, typically from a nib.

      let mainQueue = DispatchQueue.main
      mainQueue.sync {
          print("造成当前线程:\(Thread.current)死锁")
      }
}

同时主队列中不应该添加耗时的任务,因为系统的UI相关事务都是在主线程队列中完成的,大量大耗时操作可能会造成卡顿,应该避免。

主队列最常用的方法是当子线程需要通知主线程做一些UI上面的操作时,结合子线程使用:

let queue = DispatchQueue(label: "com.roki.thread")
queue.async {
    // 大量耗时操作
    print("大量耗时操作线程:\(Thread.current)")
    Thread.sleep(forTimeInterval: 2)

    DispatchQueue.main.async {
        //回到主线程操作UI
       print("回到主线程:\(Thread.current)")
    }
}

DF993F5D-6A1D-4869-A7E8-5E9D871915D8.png

2. 全局队列

全局队列是由系统创建的,默认是并行的。全局队列具体运行在哪一个线程,是由系统维护一个线程池,然后挑选其中的一至多条线程来使用。哪条线程会被使用是未知的,是由系统根据当前的并发任务,处理器的负载等情况来决定的。

  • 全局并发同步队列
override func viewDidLoad() {
    super.viewDidLoad()
    // Do any additional setup after loading the view, typically from a nib.

    for i in 1...10 {
        DispatchQueue.global().sync {
            //全局并发同步
            Thread.sleep(forTimeInterval: 2)
            print("线程\(Thread.current)正在执行\(i)号任务")
        }
    }
}

【iOS】Swift4.0 GCD的使用笔记_第1张图片

从终端输出我们可以知道任务被顺序执行了,这是因为虽然当前是一个并发队列,但是是同步执行的。同步操作会使得在前一个任务完成后才去执行下一个任务。同步与异步的区别还在于它不会创建新的线程,而是直接在当前线程中执行了相关的任务,当前线程是主线程。同步会阻塞当前线程。

  • 全局并发异步队列
override func viewDidLoad() {
    super.viewDidLoad()
    // Do any additional setup after loading the view, typically from a nib.

    for i in 1...10 {
        DispatchQueue.global().async {
            //全局并发异步
            Thread.sleep(forTimeInterval: 2)
            print("线程\(Thread.current)正在执行\(i)号任务")
        }
    }
}

【iOS】Swift4.0 GCD的使用笔记_第2张图片

从终端输出我们可以知道任务被随机执行了,而且被分配在多个子线程中执行的,这符合并发的本质。另外需要注意的是全局并发异步队列,系统在挑选来执行任务的线程的时候,会挑选除了主线程之外的其他线程。

3. 自定义队列

除了上述队列之外,我们还可以使用DispatchQueue创建自定义的队列。
let queue = DispatchQueue(label: "com.roki.thread")
需要注意的是上述创建自定义队列的方式,默认创建的是串行队列。
还有一种创建自定义队列的方法是:

let queue = DispatchQueue(label: "com.custom.thread", qos: DispatchQoS.default, attributes: DispatchQueue.Attributes.concurrent)

iOS10.0 之后上述API更新为:

let queue = DispatchQueue(label: "com.custom.thread", qos: DispatchQoS.default, attributes: DispatchQueue.Attributes.concurrent, autoreleaseFrequency: .workItem, target: nil)

参数说明:
1. label 表示队列标签
2. qos 表示设置队列的优先级
- .userInteractive 需要用户交互的,优先级最高,和主线程一样
- .userInitiated 即将需要,用户期望优先级,优先级高比较高
- .default 默认优先级
- .utility 需要执行一段时间后,再通知用户,优先级低
- *.background 后台执行的,优先级比较低
- *.unspecified 不指定优先级,最低
3. attributes 表示队列类型,默认为串行队列,设置为.concurrent表示并行队列。iOS 10.0之后 attributes 新增.initiallyInactive属性表示当前队列是不活跃的,它需要调用DispatchQueueactivate方法来执行任务。
4. autoreleaseFrequency 表示自动释放频率,设置自动释放机制。
- .inherit 表示不确定,之前默认的行为也是现在的默认值
- .workItem 表示为每个执行的项目创建和排除自动释放池, 项目完成时清理临时对象
- .never 表示GCD不为您管理自动释放池

  • 同步串行队列
    其实同步串行队列,没什么意思的,不管是同步操作还是串行操作都会导致任务被一个一个的执行。这个操作尤其是在主线程执行的时候需要注意,避免造成线程的卡顿。
let queue = DispatchQueue(label: "com.custom.thread")
queue.sync {
   //同步串行队列
}
  • 异步串行队列
    因为是串行队列,即使是异步执行的,任务也是按照顺序依次执行的,但是在子线程中执行的。
let queue = DispatchQueue(label: "com.custom.thread")
queue.async {
   //异步串行队列
}

【iOS】Swift4.0 GCD的使用笔记_第3张图片

根据iOS10.0 之后attributes新增的.initiallyInactive属性,我们可以创建不活跃队列。
- 同步串行不活跃队列

let queue = DispatchQueue(label: "com.custom.thread", qos: DispatchQoS.default, attributes: DispatchQueue.Attributes.initiallyInactive, autoreleaseFrequency: .workItem, target: nil)
queue.sync {
   //同步串行不活跃队列
}
queue.activate()
  • 异步并行不活跃队列
let queue = DispatchQueue(label: "com.custom.thread", qos: DispatchQoS.default, attributes: [.initiallyInactive, .concurrent], autoreleaseFrequency: .workItem, target: nil)
queue.async {
   //异步并行不活跃队列
}
queue.activate()
  • 同步并行队列
    只要涉及到同步的,都不会开启新线程,会在当前线程执行任务,同时任务只能依次执行。
let queue = DispatchQueue(label: "com.custom.thread", qos: DispatchQoS.default, attributes: DispatchQueue.Attributes.concurrent)
for i in 1...10 {
     queue.sync {
        //并发同步队列
        Thread.sleep(forTimeInterval: 2)
        print("线程\(Thread.current)正在执行\(i)号任务")
     }
}

【iOS】Swift4.0 GCD的使用笔记_第4张图片

  • 异步并行队列
    异步并行队列就会在多个线程中,随机执行任务。
let queue = DispatchQueue(label: "com.custom.thread", qos: DispatchQoS.default, attributes: DispatchQueue.Attributes.concurrent)
for i in 1...10 {
     queue.async {
        //并发异步
        Thread.sleep(forTimeInterval: 2)
        print("线程\(Thread.current)正在执行\(i)号任务")
     }
}

【iOS】Swift4.0 GCD的使用笔记_第5张图片

4. 任务组(DispatchGroup)

如果我们想监听多个任务的执行情况,那么我们需要将任务(异步、同步、串行、并行)都添加到任务组中,然后通过DispatchGroupnotify函数就可以监听是否组内任务都已经完成。

let group = DispatchGroup()
let queue = DispatchQueue(label: "com.custom.thread", qos: DispatchQoS.default, attributes: DispatchQueue.Attributes.concurrent)
for i in 1...10 {
    queue.async(group: group) {
       //并发异步
       Thread.sleep(forTimeInterval: 2)
       print("线程\(Thread.current)正在执行\(i)号任务")
   }
}

group.notify(queue: DispatchQueue.main) {
     // 通知主线程,子线程操作已完成
     print("所有任务都已经完成")
}

【iOS】Swift4.0 GCD的使用笔记_第6张图片

5. 任务对象(DispatchWorkItem)

在Swift4.0 中使用DispatchWorkItem代替原来OC中的dispatch_block_t。 在DispatchQueue执行操作,除了直接传了一个() -> Void 类型的闭包外,还可以传入一个DispatchWorkItem任务对象。DispatchWorkItem的初始化方法可以配置QosDispatchWorkItemFlags,但是这两个参数都有默认参数,所以也可以只传入一个闭包。
DispatchWorkItemFlags枚举中assignCurrentContext表示QoS根据创建时的context决定。 值得一提的是DispatchWorkItem也有wait方法,使用方式和DispatchGroup一样。调用会等待这个workItem执行完。

let queue = DispatchQueue(label: "com.custom.thread", qos: DispatchQoS.default, attributes: DispatchQueue.Attributes.concurrent)
let workItem = DispatchWorkItem {
     Thread.sleep(forTimeInterval: 2)
     print("线程\(Thread.current)正在执行任务")
}
queue.async(execute: workItem)

print("before waiting")
workItem.wait()
print("after waiting")

A25890FA-C5B3-4000-94D1-D00044663A1A.png

你可能感兴趣的:(iOS)