本文是我在上海 T 沙龙4月7日分享内容的文字版总结和拓展。相关视频和文档请见链接：深入浅出 iOS 并发编程
其中主要内容包括：GCD与Operation的用法、并发编程中常见的问题、使用Operation进行流程化开发示范。
什么是并发编程
在大多数场景下，我们所写的代码是逐行顺序执行——在固定的时段内，程序只执行一个任务。而所谓并发编程，就是指在固定的时段内，程序执行多个任务。举个例子，当我们在微博 App 的首页滑动浏览时，微博也在从网络端预加载新的内容或者图片。并发编程可以充分利用硬件性能，合理分配软件资源，带来优秀的用户体验。在 iOS 开发中，我们主要依靠 GCD 和 Operation 来操作线程切换、异步操作，从而实现并发编程。
在 iOS 并发编程中，我们要知道这几个基本概念：
- 串行（Serial）：在固定时间内只能执行单个任务。例如主线程，只负责 UI 显示。
- 并发（Concurrent）：在固定时间内可以执行多个任务。注意，它和并行（Parallel）的区别在于，并发不会同时执行多个任务，而是通过在任务间不断切换去完成所有工作。
- 同步（Sync）：会把当前的任务加入到队列中，除非该任务执行完成，线程才会返回继续运行，也就是说同步会阻塞线程。任务在执行和结束一定遵循先后顺序，即先执行的任务一定先结束。
- 异步（Async）：会把当前的任务加入到队列中，但它会立刻返回，无需等任务执行完成，也就是说异步不会阻塞线程。任务在执行和结束不遵循先后顺序。可能先执行的任务先结束，也可能后执行的任务先结束。
为了进一步说明说明串行/并发与同步/异步之间的关系，我们来看下面这段代码会打印出什么内容：
// serial, sync
serialQueue.sync {
print(1)
}
print(2)
serialQueue.sync {
print(3)
}
print(4)
// serial, async
serialQueue.async {
print(1)
}
print(2)
serialQueue.async {
print(3)
}
print(4)
// serial, sync in async
print(1)
serialQueue.async {
print(2)
serialQueue.sync {
print(3)
}
print(4)
}
print(5)
// serial, async in sync
print(1)
serialQueue.sync {
print(2)
serialQueue.async {
print(3)
}
print(4)
}
print(5)
首先，在串行队列上进行同步操作，所有任务将顺序发生，所以第一段的打印结果一定是 1234；
其次，在串行队列上进行异步操作，此时任务完成的顺序并不保证。所以可能会打印出这几种结果：1234 ，2134，1243，2413，2143。注意 1 一定在 3 之前打印出来，因为前者在后者之前派发，串行队列一次只能执行一个任务，所以一旦派发完成就执行。同理 2 一定在 4 之前打印，2 一定在 3 之前打印。
接着，对同一个串行队列中进行异步、同步嵌套。这里会构成死锁（具体原因参见下文），所以只会打印出 125 或者 152。
最后，在串行队列中进行同步、异步嵌套，不会构成死锁。这里会打印出 3 个结果：12345，12435，12453。这里1一定在最前，2 一定在 4 前，4 一定在 5 前。
现在我们把串行队列改为并发队列：
// concurrent, sync
concurrentQueue.sync {
print(1)
}
print(2)
concurrentQueue.sync {
print(3)
}
print(4)
// concurrent, async
concurrentQueue.async {
print(1)
}
print(2)
concurrentQueue.async {
print(3)
}
print(4)
// concurrent, sync in async
print(1)
concurrentQueue.async {
print(2)
concurrentQueue.sync {
print(3)
}
print(4)
}
print(5)
// concurrent, async in sync
print(1)
concurrentQueue.sync {
print(2)
concurrentQueue.async {
print(3)
}
print(4)
}
print(5)
首先，在并发队列上进行同步操作，所有任务将顺序执行、顺序完成，所以第一段的打印结果一定是 1234；
其次，在并发队列上进行异步操作，因为并行对列有多个线程 。所以这里只能保证 24 顺序执行，13 乱序，可能插在任意位置：2413 ，2431，2143，2341，2134，2314。
接着，对同一个并发队列中进行异步、同步嵌套。这里不会构成死锁，因为同步操作只会阻塞一个线程，而并发队列对应多个线程。这里会打印出 4 个结果：12345，12534，12354，15234。注意同步操作保证了 3 一定会在 4 之前打印出来。
最后，在并发队列中进行同步、异步嵌套，不会构成死锁。而且由于是并发队列，所以在运行异步操作时也同时会运行其他操作。这里会打印出 3 个结果：12345，12435，12453。这里同步操作保证了 2 和 4 一定分别在 3 和 5 之前打印出来。
在实际开发中，我们还需要知道主线程的特性、GCD 和 Operation 的 API、如发现并调试并发编程中的技巧。
GCD vs. Operation
在 iOS 开发中，我们一般用 GCD 和 Operation 来处理并发编程问题。我们先来看看 GCD 的基本用法：
// serial queue
let serialQueue = DispatchQueue(label: "serial")
// global queue, gcd defined concurrent queue
let globalQueue = DispatchQueue.global(qos: .default)
// custom concurrent queue
let concurrentQueue = DispatchQueue(label: "concurrent", attributes: .concurrent)
其中，全局队列的优先级由 QoS (Quality of Service)决定。如果不指定优先级，就是默认（default）优先级。另外还有 background，utility，user-Initiated，unspecified，user-Interactive。下面按照优先级顺序从低到高来排列：
- Background：用来处理特别耗时的后台操作，例如同步、数据持久化。
- Utility：用来处理需要一点时间而又不需要立刻返回结果的操作。特别适用于网络加载、计算、输入输出等。
- Default：默认优先级。一般来说开发者应该指定优先级。属于特殊情况。
- User-Initiated：用来处理用户触发的、需要立刻返回结果的操作。比如打开用户点击的文件、加载图片等。
- User-Interactive：用来处理用户交互的操作。一般用于主线程，如果不及时响应就可能阻塞主线程的操作。
- Unspecified：未确定优先级，由系统根据不同环境推断。比如使用过时的 API 不支持优先级，此时就可以设定为未确定优先级。属于特殊情况。
在日常开发中，GCD 的常见应用有处理后台任务、延时、单例（Objective-C）、线程组等操作，这里不作赘述。下面我们来看看 Operation 的基本操作：
// serial queue
let serialQueue = OperationQueue()
serialQueue.maxConcurrentOperationCount = 1
// concurrent queue
let concurrentQueue = OperationQueue()
Operation 作为 NSObject 的子类，一般被用于单独的任务。我们将其继承重写之后加入到 OperationQueue 中去运行。iOS 亦提供 BlockOperation 这个子类去方便地执行多个代码片段。相比于 GCD，Operation 最主要的特点在于其拥有暂停、继续、终止等多个可控状态，从而可以更加灵活得适应并发编程的场景。
基于 Operation 和 GCD API 的特点，我们可以得出以下结论：GCD 适用于处理并行开发中的简单小任务，总体写法轻便快捷；Operation 适合于封装模块化的任务，支持多任务之间相互依赖的场景。两者之间的区别同 UIAnimation 和 CALayor Animation 差别异曲同工——由此可见苹果在设计 API 时一以贯之的思路：提供一个简单快捷的 API 满足80%的场景，在提供一套更全面的 API 应对剩下20%更复杂的场景。
并发编程中常见问题
在并发编程中，一般会面对这样的三个问题：竞态条件、优先倒置、死锁问题。针对 iOS 开发，它们的具体定义为：
- 竞态条件（Race Condition）。指两个或两个以上线程对共享的数据进行读写操作时，最终的数据结果不确定的情况。例如以下代码：
var num = 0
DispatchQueue.global().async {
for _ in 1…10000 {
num += 1
}
}
for _ in 1…10000 {
num += 1
}
最后的计算结果 num 很有可能小于 20000，因为其操作为非原子操作。在上述两个线程对num进行读写时其值会随着进程执行顺序的不同而产生不同结果。
竞态条件一般发生在多个线程对同一个资源进行读写时。解决方法有两个，第一是串行队列加同步操作，无论读写，指定时间只能优先做当前唯一操作，这样就保证了读写的安全。其缺点是速度慢，尤其在大量读写操作发生时，每次只能做单个读或写操作的效率实在太低。另一个方法是，用并发队列和 barrier flag，这样保证此时所有并发队列只进行当前唯一的写操作（类似将并发队列暂时转为串行队列），而无视其他操作。
- 优先倒置（Priority Inverstion）。指低优先级的任务会因为各种原因先于高优先级任务执行。例如以下代码：
var highPriorityQueue = DispatchQueue.global(qos: .userInitiated)
var lowPriorityQueue = DispatchQueue.global(qos: .utility)
let semaphore = DispatchSemaphore(value: 1)
lowPriorityQueue.async {
semaphore.wait()
for i in 0...10 {
print(i)
}
semaphore.signal()
}
highPriorityQueue.async {
semaphore.wait()
for i in 11...20 {
print(i)
}
semaphore.signal()
}
上述代码如果没有 semaphore，高优先权的 highPriorityQueue 会优先执行，所以程序会优先打印完 11 到 20。而加了 semaphore 之后，低优先权的 lowPriorityQueue 会先挂起 semaphore，高优先权的highPriorityQueue 就只有等 semaphore 被释放才能再执行打印。
也就是说，低优先权的线程可以锁上某种高优先权线程需要的资源，从而优于迫使高优先权的线程等待低优先权的线程，这就叫做优先倒置。其对应的解决方法是，对同一个资源不同队列的操作，我们应该用同一个QoS指定其优先级。
- 死锁问题（Dead Lock）。指两个或两个以上的线程，它们之间互相等待彼此停止执行，以获得某种资源，但是没有一方会提前退出的情况。iOS 中有个经典的例子就是两个 Operation 互相依赖：
let operationA = Operation()
let operationB = Operation()
operationA.addDependency(operationB)
operationB.addDependency(operationA)
还有一种经典的情况，就是在对同一个串行队列中进行异步、同步嵌套：
serialQueue.async {
serialQueue.sync {
}
}
因为串行队列一次只能执行一个任务，所以首先它会把异步 block 中的任务派发执行，当进入到 block 中时，同步操作意味着阻塞当前队列 。而此时外部 block 正在等待内部 block 操作完成，而内部block 又阻塞其操作完成，即内部 block 在等待外部 block 操作完成。所以串行队列自己等待自己释放资源，构成死锁。
对于死锁问题的解决方法是，注意Operation的依赖添加，以及谨慎使用同步操作。其实聪明的读者应该已经发现，在主线程使用同步操作是一定会构成死锁的，所以我个人建议在串行队列中不要使用同步操作。
尽管我们已经知道了并发编程中的问题，以及其对应方法。但是日常开发中，我们怎样及时发现这些问题呢？其实 Xcode 提供了一个非常便利的工具 —— Thread Sanitizer (TSan)。在Schemes中勾选之后，TSan就会将所有的并发问题在 Runtime 中显示出来，如下图：
这里我们有7个线程问题，TSan清晰地告诉了我们这是读写问题，展开之后会告诉我们具体触发代码，十分方便。16年的WWDC上，苹果也郑重向大家宣告，如果有并发问题，请记得用 TSan。
Operation 流程化开发
上文中提到 Operation 特别适合模块化工作，也支持多任务的互相依赖。这里我们就来看一个具体的开发案例吧：
实现一个相册 App，其首页是个滑动列表（Table View）。列表每行展示加上了滤镜的图片。具体实现如下图：
仔细分析一下相关的操作，实际上就是三步：先加载数据，然后解码成图片，最后再给图片加上滤镜。所以用 Operation 实现起来如下图：
对于加载数据，我们可以定义如下的 Operation 子类来进行操作：
class DataLoadOperation: Operation {
fileprivate let url: URL
fileprivate var loadedData: Data?
fileprivate let completion: ((Data?) -> ())?
init(url: URL, completion: ((Data?) -> ())? = nil) {
...
}
override func main() {
if isCancelled { return }
ImageService.loadData(at: url) { data in
if isCancelled { return }
loadedData = data
completion?(data)
}
}
}
这里我们要注意，DataLoadOperation中的三个变量皆为私有。这是因为其实后续图片解码操作并不关心数据是如何操作的，它只关心是否能提供解码图片的数据，所以我们可以用 Protocol 来提供这个借口即可：
// 此协议定义应和 ImageDecodeOperation 放在同一文件
protocol ImageDecodeOperationDataProvider {
var encodedData: Data? { get }
}
// 次扩展应和 DataLoadOperation 放在同一文件
extension DataLoadOperation: ImageDecodeOperationDataProvider {
var encodedData: Data? { return loadedData }
}
接着再来看看解码图片的 Operation 如何实现：
class ImageDecodeOperation: Operation {
fileprivate let inputData: Data?
fileprivate var outputImage: UIImage?
fileprivate let completion: ((UIImage?) -> ())?
init(data: Data?, completion: ((UIImage?) -> ())? = nil) {
...
}
override func main() {
let encodedData: Data?
if isCancelled { return }
if let inputData = inputData {
encodedData = inputData
} else {
let dataProvider = dependencies
.filter { $0 is ImageDecodeOperationDataProvider }
.first as? ImageDecodeOperationDataProvider
encodedData = dataProvider?.encodedData
}
guard let data = encodedData else { return }
if isCancelled { return }
if let decodedData = Decoder.decodeData(data) {
outputImage = UIImage(data: decodedData)
}
if isCancelled { return }
completion?(outputImage)
}
}
extension ImageDecodeOperation: ImageFilterDataProvider {
var image: UIImage? { return outputImage }
}
最后我们再来看 ImageFilterOperation 及其子类如何实现。这里由于直接输出 Image，所以就无需用：
protocol ImageFilterDataProvider {
var image: UIImage? { get }
}
class ImageFilterOperation: Operation {
fileprivate let filterInput: UIImage?
fileprivate var filterOutput: UIImage?
fileprivate let completion: ((UIImage?) -> ())?
init(image: UIImage?, completion:
((UIImage?) -> ())? = nil) {
...
}
var filterInput: UIImage? {
var image: UIImage?
if let inputImage = _filterInput {
image = inputImage
} else if let dataProvider = dependencies
.filter({ $0 is ImageFilterDataProvider })
.first as? ImageFilterDataProvider {
image = dataProvider.image
}
return image
}
}
// LarkFilter 和 ReyesFilter 的实现也类似
class MoonFilterOperation : ImageFilterOperation {
override func main() {
if isCancelled { return }
guard let filterInput = filterInput else { return }
if isCancelled { return }
filterOutput = filterInput.applyMoonEffect()
if isCancelled { return }
completion(imageFiltered)
}
}
最后我们用 OperationQueue 将这些 Operation 拼接在一起：
let operationQueue = OperationQueue()
let dataLoadOperation = DataLoadOperation(url: url)
let imageDecodeOperation = imageDecodeOperation(data: nil)
let moonFilterOperation = MoonFilterOperation(image: nil, completion: completion)
let operations = [dataLoadOperation, imageDecodeOperation, moonFilterOperation]
// Add dependencies
imageDecodeOperation.addDependency(dataLoadOperation)
moonFilterOperation.addDependency(imageDecodeOperation)
operationQueue.addOperations(operations, waitUntilFinished: false)
大功告成。从上面我们可以发现，每个操作模块都可以用 Operation 进行自定义和封装。模块的对应逻辑非常清楚，代码复用率和灵活度也非常之高。如果要继续改进，我们还可以实现一个 AsyncOperation 的类，然后让 DataLoadOperation 继承该类，这样数据加载由同步变为异步，其效率会大大提高。
总结
iOS 开发中，并发编程主要用于提升 App 的运行性能，保证App实时响应用户的操作。主线程一般用于负责 UI 相关操作，如绘制图层、布局、交互相应。很多 UIKit 相关的控件如果不在主线程操作，会产生未知效果。Xcode 中的 Main Thread Checker 可以将相关问题检测出来并报错。
其他线程例如后天线程一般用来处理比较耗时的工作。网络请求、数据解析、复杂计算、图片的编码解码管理等都属于耗时的工作，应该放在其他线程处理。iOS 提供了两套灵活丰富的 API：GCD 和 Operation。GCD的优点在于简单快捷，Operation 胜在功能丰富、适合模块化操作。我们享受其便利的同时，也应该及时发现和处理并发编程中的三大问题。
