9.多线程

如何创建一个线程

多线程可以做什么

• 网络请求
• IO
• 计算
• 数据模型转化
• ......

多线程编程的方式

• Thread
• Cocoa Operation(Operation和OperationQueue)
• Grand Central Dispath(GCD)

Thread

• Tread在三种多线程技术中是最轻量级的，但需要自己管理线程的生命周期和线程同步。线程同 步对数据的加锁会有一定的系统开销。

快捷方式创建

• detachNewThread(_ block: @escaping () -> Void)
• detachNewThreadSelector(_ selector: Selector, toTarget target: Any, with argument: Any?)

初始化器

• Thread(target:, selector:, object:)

  
  01

Cocoa Operation

• 面向对象
• Operation + OperationQueue
• 取消，依赖，任务优先级，复杂逻辑，保存业务状态，子类化

Operation

Operation
BlockOperation

Operation

isReady
isExecuting
isFinished
isCancelled

Operation

• sync
  main()

• async
  start()
  isAsynchronous
  isExecuting
  isFinished

  
  02

OperationQueue

• OperationQueue 队列里可以加入很多个 Operation，可以把 OperationQueue 看做一个线程池，可往线程池中添加操作 (Operation)到队列中。
• 底层使用GCD。
• maxConcurrentOperationCount 可以设置最大并发数。
• defaultMaxConcurrentOperationCount 根据当前系统条件动态确定的最大并发数。
• 可以取消所有 Operation，但是当前正在执行的不会取消。
• 所有 Operation 执行完毕后退出销毁。

BlockOperation

02

继承Operation

03

Operation 完成的回调

04

GCD

• 任务 + 队列
• 易用
• 效率
• 性能

05

• 创建管理Queue
• 提交Job
• Dispatch Group
• 管理Dispatch Object
• 信号量Semaphore
• 队列屏障Barrier
• Dispatch Source
• Queue Context数据
• Dispatch I/O Channel
• Dispatch Data 对象

GCD-队列

• 主队列: 任务在主线程执行
• 并行队列: 任务会以先进先出的顺序入列和出列，但是因为多个任务可以并行执行，所以完成顺 序是不一定的。
• 串行队列: 任务会以先进先出的顺序入列和出列，但是同一时刻只会执行一个任务

GCD-队列API

• Dispatch.main
• Dispatch.global
• DispatchQueue(label:, qos:, attributes:, autoreleaseFrequency:, target:)
• queue.label
• setTarget(queue: DispatchQueue?)

06

• 最终的目标队列都是主队列和全局队列
• 如果把一个并行队列的目标队列设置为一个串行队列，那么并行队列将不再并行
• 如果多个队列的目标队列都设置为同一个串行队列，那么这多个队列连同目标队列里的任务都将串行执行
• 如果设置目标队列形成环了，结果是不可预期的
• 如果在一个队列正在执行任务的时候更换目标队列，结果也是不可预期的

GCD-基本操作

sync
async
asyncAfter

GCD-串行 vs 并行

07

GCD-同步 vs 异步

08

GCD-sync

• 提交任务到当前队列里，并且直到任务执行完成，当前队列才会返回。

  
  09

GCD-async

• 调度一个任务去立即执行，但是不用等任务执行完当前队列就会返回

GCD-asyncAfter

• 调度一个任务去多久之后执行，但是不用等任务执行完当前队列就会返回

  
  10

GCD 高级特性

DispatchGroup

11

DispatchGroup-wait

12

DispatchGroup-notify

13

DispatchSource

• 简单来说，dispatch source是一个监视某些类型事件的对象。当这些事件发生时，它自动将一 个 task 放入一个dispatch queue的执行例程中。

• Mach port send right state changes.

• Mach port receive right state changes.

• External process state change.

• File descriptor ready for read.

• File descriptor ready for write.

• Filesystem node event.

• POSIX signal.

• Custom timer.

• Custom event.

DispatchSource-Timer

14

GCD 源码剖析

15 16 17 18 19 20 21 22 23

• lock_value就是dq_state,一个32位的整数。通过判断((lock_value ^ tid) & DLOCK_OWNER_MASK)是 否为0，来判断当前的串行队列是否已被同一个线程所获取。如果当前队列已经被当前线程获取，即当前 线程在执行一个串行任务中，如果此时我们在阻塞等待一个新的串行任务，则会发生死锁。因此，在新版 GCD中，当((lock_value ^ tid) & DLOCK_OWNER_MASK) == 0 时，就会主动触发crash来避免死锁。

  
  24

• 线程A在串行队列dq中执行任务task1的过程中，如果再向dq中投递串行任务task2，同时还要求必须阻塞当前 线程，来等待task2结束(sync投递task2)，那么这时候会发生死锁。

• 因为这时候task1还没有结束，串行队列不会去执行task2，而我们又要在当前线程等待task2的结束才肯继续执 行task1，即task1在等task2，而task2也在等task1，循环等待，形成死锁。

  
  25

线程安全和同步

死锁

• 死锁是指两个或两个以上的进程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种 阻塞的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了 死锁。

  
  26

临界区

• 就是一段代码不能被并发执行，也就是，两个线程不能同时执行这段代码。

竞态条件

• 两个或多个线程读写某些共享数据，而最后的结果取决于线程运行的精确时序。

优先级反转

27

并发与并行

28

Locks

29

SpinLock

• 线程通过busy-wait-loop的方式来获取锁，任时刻只有一个线程能够获得锁，其他线程忙等待 直到获得锁。

  
  30

• 临界区尽量简短，控制在100行代码以内，不要有显式或者隐式的系统调用，调用的函数也尽量 简短。

• 保证访问锁的线程全部都处于同一优先级。

synchronized

31

• 只有传同样的对象给synchronized，才能起到加锁作用
• 如果传nil，是无法起到加锁作用的
• 可以重入
• synchronized不会持有传给它的对象

32 33

• SyncData是可以重用的(threadCount==0)

• 存在全局的map里

  
  34
  35

36 37 38 39

多线程典型场景

• 一个页面有三个网络请求，需要在三个网络请求都返回的时候刷新界面 。
• 实现一个线程安全的Array的读和写。
• 编写一个多线程下载器，可以执行多个下载任务，每个任务可以保存当下下载字节数，总字节 数，可以设置回调得到当前下载进度
• 需要在主线程等待一个异步任务返回，才能继续执行下面的逻辑，但是又不希望堵塞用户事 件。

安全的Array

40 41

• 如果在一段时间内只有读操作，我们是不需要加锁的，而上述 NSLock 的方式则仍然强制每一 次读操作都加锁等待，对性能造成不小的影响，尤其是我们对数组的读操作远远多于写操作的 时候，这个性能的影响就会相当可观。那么怎么解决这一问题呢?

• 一个队列加两个方法
  首先是并行队列，既然我们要保持多线程环境并行操作的优势，那我们肯定要选择并行队列。
  二是 sync 方法，这个方法来封装我们的读操作，读操作的发起方需要在调用读方法的时候能 直接拿到返回值，而不是在异步回调里面获取。
  三是 async 方法使用 barrier flag，这个方法来封装我们的写操作，这个方法起到一个栅栏的 作用,它等待所有位于 barrier async 函数之前的操作执行完毕后执行,并且在 barrier async 函数执行之后， barrier async 函数之后的操作才会得到执行。

42

其他模式

• Promise
• Pipeline
• Master-Slave
• Serial Thread Confinement

Promise

43

• 在需要多个操作的时候，会导致多个回调函数嵌套，导致代码不够直观，就是常说的 Callback Hell。

• 如果几个异步操作之间并没有前后顺序之分(例如不需要前一个请求的结果作为后一个请求的 参数)时，同样需要等待上一个操作完成再实行下一个操作。

• 丧失了 return 特性。

• 所谓 Promise，就是一个对象，用来传递异步操作的消息。它代表了某个未来才会知道结果的 事件(通常是一个异步操作)，并且这个事件提供统一的 API，可供进一步处理。

• 对象的状态不受外界影响。Promise 对象代表一个异步操作，有三种状态:Pending(进行中，又称Incomplete)、Resolved(已完成，又称 Fulfilled)和Rejected(已失败)。只有异步操作的结果，可以决定当前是哪一种状态，任何其他操作都无法改变这个状态。这也是 Promise 这个名字的由来，它的英语意思就是「承诺」，表示其他手段无法改变。

• 一旦状态改变，就不会再变，任何时候都可以得到这个结果。Promise对象的状态改变，只有两种可能:从 Pending 变为 Resolved 和从 Pending 变为 Rejected。只要这两种情况发生，状态就凝固了，不会再变了，会一直保持这个结果。就算改变已经发生了，你再对 Promise 对象添加回调函数，也会立即得到这个结果。这与事件(Event)完全不同，事件的特点是，如果你错过了它，再去监听，是得不到结果的。

44

Pipeline

• 将一个任务分解为若干个阶段(Stage)，前阶段的输出为下阶段的输入，各个阶段由不同的工作者线程负责执行。
• 各个任务的各个阶段是并行(Parallel)处理的。
• 具体任务的处理是串行的，即完成一个任务要依次执行各个阶段，但从整体任务上看，不同任务的各个阶段的执行是并行的。

45

Master/Slave

• 将一个任务分解为若干个语义等同的子任务，并由专门的工作者线程来并行执行这些子任务，既
  提高计算效率，又实现了信息隐藏。

46

Serial Thread Confinement

• 如果并发任务的执行涉及某个非线程安全对象，而很多时候我们又不希望因此而引入锁。
• 通过将多个并发的任务存入队列实现任务的串行化，并为这些串行化任务创建唯一的工作者线程进行处理。

应用实例

public typealias Task = () -> Void

public struct Asyncs {
    public static func async(_ task: @escaping Task) {
        _async(task)
    }
    public static func async(_ task: @escaping Task,
                             _ mainTask: @escaping Task) {
        _async(task, mainTask)
    }
    private static func _async(_ task: @escaping Task,
                               _ mainTask: Task? = nil) {
        let item = DispatchWorkItem(block: task)
        DispatchQueue.global().async(execute: item)
        if let main = mainTask {
            item.notify(queue: DispatchQueue.main, execute: main)
        }
    }
    
    @discardableResult
    public static func delay(_ seconds: Double,
                             _ block: @escaping Task) -> DispatchWorkItem {
        let item = DispatchWorkItem(block: block)
        DispatchQueue.main.asyncAfter(deadline: DispatchTime.now() + seconds,
                                      execute: item)
        return item
    }
    
    @discardableResult
    public static func asyncDelay(_ seconds: Double,
                                  _ task: @escaping Task) -> DispatchWorkItem {
        return _asyncDelay(seconds, task)
    }
    
    @discardableResult
    public static func asyncDelay(_ seconds: Double,
                                  _ task: @escaping Task,
                                  _ mainTask: @escaping Task) -> DispatchWorkItem {
        return _asyncDelay(seconds, task, mainTask)
    }
    
    private static func _asyncDelay(_ seconds: Double,
                                    _ task: @escaping Task,
                                    _ mainTask: Task? = nil) -> DispatchWorkItem {
        let item = DispatchWorkItem(block: task)
        DispatchQueue.global().asyncAfter(deadline: DispatchTime.now() + seconds,
                                          execute: item)
        if let main = mainTask {
            item.notify(queue: DispatchQueue.main, execute: main)
        }
        return item
    }
    

}

public struct Cache {
    private static var data = [String: Any]()
//    private static var lock = DispatchSemaphore(value: 1)
//    private static var lock = NSLock()
    private static var lock = NSRecursiveLock()
    
    public static func get(_ key: String) -> Any? {
        data[key]
    }
    
    public static func set(_ key: String, _ value: Any) {
//        lock.wait()
//        defer { lock.signal() }
        
        lock.lock()
        defer { lock.unlock() }
        
        data[key] = value
    }
}