如何创建一个线程
多线程可以做什么
- 网络请求
- 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
继承Operation
Operation 完成的回调
GCD
- 任务 + 队列
- 易用
- 效率
- 性能
- 创建管理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?)
- 最终的目标队列都是主队列和全局队列
- 如果把一个并行队列的目标队列设置为一个串行队列，那么并行队列将不再并行
- 如果多个队列的目标队列都设置为同一个串行队列，那么这多个队列连同目标队列里的任务都将串行执行
- 如果设置目标队列形成环了，结果是不可预期的
- 如果在一个队列正在执行任务的时候更换目标队列，结果也是不可预期的
GCD-基本操作
sync
async
asyncAfter
GCD-串行 vs 并行
GCD-同步 vs 异步
GCD-sync
-
提交任务到当前队列里，并且直到任务执行完成，当前队列才会返回。
09
GCD-async
- 调度一个任务去立即执行，但是不用等任务执行完当前队列就会返回
GCD-asyncAfter
-
调度一个任务去多久之后执行，但是不用等任务执行完当前队列就会返回
10
GCD 高级特性
DispatchGroup
DispatchGroup-wait
DispatchGroup-notify
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
GCD 源码剖析
-
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
临界区
- 就是一段代码不能被并发执行，也就是，两个线程不能同时执行这段代码。
竞态条件
- 两个或多个线程读写某些共享数据，而最后的结果取决于线程运行的精确时序。
优先级反转
并发与并行
Locks
SpinLock
-
线程通过busy-wait-loop的方式来获取锁，任时刻只有一个线程能够获得锁，其他线程忙等待 直到获得锁。
30 临界区尽量简短，控制在100行代码以内，不要有显式或者隐式的系统调用，调用的函数也尽量 简短。
保证访问锁的线程全部都处于同一优先级。
synchronized
- 只有传同样的对象给synchronized，才能起到加锁作用
- 如果传nil，是无法起到加锁作用的
- 可以重入
- synchronized不会持有传给它的对象
- SyncData是可以重用的(threadCount==0)
-
存在全局的map里
34
35
多线程典型场景
- 一个页面有三个网络请求，需要在三个网络请求都返回的时候刷新界面 。
- 实现一个线程安全的Array的读和写。
- 编写一个多线程下载器，可以执行多个下载任务，每个任务可以保存当下下载字节数，总字节 数，可以设置回调得到当前下载进度
- 需要在主线程等待一个异步任务返回，才能继续执行下面的逻辑，但是又不希望堵塞用户事 件。
安全的Array
- 如果在一段时间内只有读操作，我们是不需要加锁的，而上述 NSLock 的方式则仍然强制每一 次读操作都加锁等待，对性能造成不小的影响，尤其是我们对数组的读操作远远多于写操作的 时候，这个性能的影响就会相当可观。那么怎么解决这一问题呢?
- 一个队列加两个方法
首先是并行队列，既然我们要保持多线程环境并行操作的优势，那我们肯定要选择并行队列。
二是 sync 方法，这个方法来封装我们的读操作，读操作的发起方需要在调用读方法的时候能 直接拿到返回值，而不是在异步回调里面获取。
三是 async 方法使用 barrier flag，这个方法来封装我们的写操作，这个方法起到一个栅栏的 作用,它等待所有位于 barrier async 函数之前的操作执行完毕后执行,并且在 barrier async 函数执行之后， barrier async 函数之后的操作才会得到执行。
其他模式
- Promise
- Pipeline
- Master-Slave
- Serial Thread Confinement
Promise
在需要多个操作的时候，会导致多个回调函数嵌套，导致代码不够直观，就是常说的 Callback Hell。
如果几个异步操作之间并没有前后顺序之分(例如不需要前一个请求的结果作为后一个请求的 参数)时，同样需要等待上一个操作完成再实行下一个操作。
丧失了 return 特性。
所谓 Promise，就是一个对象，用来传递异步操作的消息。它代表了某个未来才会知道结果的 事件(通常是一个异步操作)，并且这个事件提供统一的 API，可供进一步处理。
对象的状态不受外界影响。Promise 对象代表一个异步操作，有三种状态:Pending(进行中，又称Incomplete)、Resolved(已完成，又称 Fulfilled)和Rejected(已失败)。只有异步操作的结果，可以决定当前是哪一种状态，任何其他操作都无法改变这个状态。这也是 Promise 这个名字的由来，它的英语意思就是「承诺」，表示其他手段无法改变。
一旦状态改变，就不会再变，任何时候都可以得到这个结果。Promise对象的状态改变，只有两种可能:从 Pending 变为 Resolved 和从 Pending 变为 Rejected。只要这两种情况发生，状态就凝固了，不会再变了，会一直保持这个结果。就算改变已经发生了，你再对 Promise 对象添加回调函数，也会立即得到这个结果。这与事件(Event)完全不同，事件的特点是，如果你错过了它，再去监听，是得不到结果的。
Pipeline
- 将一个任务分解为若干个阶段(Stage)，前阶段的输出为下阶段的输入，各个阶段由不同的工作者线程负责执行。
- 各个任务的各个阶段是并行(Parallel)处理的。
- 具体任务的处理是串行的，即完成一个任务要依次执行各个阶段，但从整体任务上看，不同任务的各个阶段的执行是并行的。
Master/Slave
- 将一个任务分解为若干个语义等同的子任务，并由专门的工作者线程来并行执行这些子任务，既
提高计算效率，又实现了信息隐藏。
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
}
}