书接上回，GCD提供了实现并发的大多数功能。可对于一些高度定制化的，可复用性极高的代码，GCD显得有点啰嗦。总不能遇到一次，写一次吧？那么今天来我们就来聊聊Operation。
Operation基本介绍
与GCD相比，Operation更具有封装的，重用的特性，我们可以将一些逻辑独立，可重用性高的代码封装到Operation中。Operation的生命周期是通过状态机控制的，如下图：
- isReady: 当Operation创建成功并准备执行时，处于此状态
- isExecuting: 当调用start方法后，进入此状态
- isCancel： 调用cancel方法时进入此状态，随后进入isFinished状态
- isFinished： 执行完毕状态
然而Operation是一个抽象类，我们不能直接用它来创建实例，只能通过创建子类来实现，好在系统为我们实现Operation的子类BlockOperation（OC中是两个，NSBlockOperation和NSInvocationOperation）.
BlockOperation:
let operation = BlockOperation {
print("BlockOperation execute..")
}
operation.start()
创建的方式很简单，直接调用start() 就可以启动。虽然我们只传了一个block，但不意味着一个Operation只能处理一个block。Operation可以处理一组block：
let say = "You are a good man !"
let operation = BlockOperation()
for word in say.split(separator: " ") {
operation.addExecutionBlock {
print(word)
}
}
operation.start()
打印的结果如下：
good
man
!
a
You
are
可以看到多个block是并发执行的。如果想要让他们串行执行，放到一个串行队列里即可。别着急，后面会讲到。
自定义Operation
既然是定义Operation的子类，那么我们首先应该看看这个神秘的父类里面到底有什么东西。
open class Operation : NSObject {
///启动Operation的入口，如果是添加到OperationQueue中，则有OperationQueue自动调用
open func start()
///主要逻辑就放在此函数里面。我们封装的代码块就放在这里面
open func main()
/// 取消任务，Operation独有的，GCD没有的功能
open func cancel()
///四种状态：需要注意一下，这里只定义了getter，并没有定义状态机，所以我们需要自己定义状态机
open var isReady: Bool { get }
open var isCancelled: Bool { get }
open var isExecuting: Bool { get }
open var isFinished: Bool { get }
/// 是否为并发，默认是非并发的
open var isConcurrent: Bool { get }
@available(iOS 7.0, *)
open var isAsynchronous: Bool { get }
/// 添加依赖关系：A依赖于B，那么A会在B执行完之后执行
open func addDependency(_ op: Operation)
///移除依赖关系
open func removeDependency(_ op: Operation)
/// 获取所有依赖关系
open var dependencies: [Operation] { get }
/// 优先级：和GCD 类似，优先级问题可以看一下上篇文章
open var queuePriority: Operation.QueuePriority
@available(iOS 4.0, *)
open var completionBlock: (() -> Void)?
@available(iOS 4.0, *)
open func waitUntilFinished()
@available(iOS, introduced: 4.0, deprecated: 8.0, message: "Not supported")
open var threadPriority: Double
@available(iOS 8.0, *)
open var qualityOfService: QualityOfService
@available(iOS 8.0, *)
open var name: String?
}
上面的代码我都加了注释，相信你应该能看明白。没有注释的部分放在后面部分来讲。我们可以总结出以下几点：
状态机需要我们自己定义：抽象类中只定义了getter方法，并没有告诉我们状态机是什么。状态机状态的改变是通过KVO的方式告诉外界的，所以在修改状态的时候，还要实现通知功能。
主要逻辑放在main()函数中
-
设置能否并发
这里我提供一个模板，每个步骤都做了详细说明，看它就够了。
CustomOperation: Operation { ///第一步：定义状态机 enum State: String { //为什么没有cancel状态呢？ 这是因为cancel并不是一种状态，而是一个动作，动作执行完之后，立马进入finished状态。官方文档中有这么一句话“Once canceled, an operation must move to the finished state.” case ready, executing, finished ///注意是fileprivate，如果定义为private，那么enum之外是不可以使用的。 ///keyPath主要用来配合KVO使用 fileprivate var keyPath: String { return "is\(rawValue.capitalized)" } } ///第二步：设置KVO private var state = State.ready { ///注意这里是四个通知，因为比如从ready 到 executing，isReady先从true变为false，然后才是isExecuting从false变为true，所以要两步 willSet { willChangeValue(forKey: state.keyPath) willChangeValue(forKey: newValue.keyPath) } didSet { didChangeValue(forKey: oldValue.keyPath) didChangeValue(forKey: state.keyPath) } } /// 第三步（一）： 重载状态机函数 override var isReady { ///如果有多层继承，要考虑父类有没有ready 所以要调用super.isReady return super.isReady && state == .ready } override var isExecuting: Bool { return state == .executing } override var isFinished: Bool { return state == .finished } override var isCancelled: Bool { return state == .finished } override func cancel() { state = .finished } /// 第三步（二）： 这部分按需配置 override var isConcurrent: Bool { ///是否并发 return true } override var isAsynchronous: Bool { ///是否异步 return true } ///第四步： 重写start和main函数 override func start() { if isCancelled { state = .finished return } ///main函数会立刻返回，不会出现main函数执行完了，state为executing的情况 main() state = .executing } override func main() { defer { self.state = .finished } //切记任务最后一定要将状态修改为finished //TODO: 做你想做的事.... } }
OperationQueue
OperationQueue的强大之处在于它可以处理批量的Operation，和GCD的DispatchQueue类似，可以进行并发控制，所以这部分内容主要介绍几点
Operation一旦添加到OperationQueue中，它将自动执行，直到结束或取消
同一个Operation不能添加到不同的OpertaionQueue中
OperationQueue的默认优先级是
.background，你可以修改优先级，但是切记之前说过的，优先级可能Operation修改，造成优先级反转问题。maxConcurrentOperationCount，可以控制Operation并发数，如果是1，那么就相当于一个串行队列
waitUntilAllOperationsAreFinished()会阻塞线程，不要在主线程调用。如果是等待一部分Operation执行完之后再执行其他任务，可以调用
addOperations(_:waitUntilFinished:)
Operation依赖
假设有A,B,C三个任务，任务B要在A之后执行，任务C要在B之后执行，既 A -> B -> C.如果控制他们的执行顺序呢？
第一种就是创建一个串行队列，OperationQueue的maxConcurrentOperationCount = 1 即可。如果是并发的呢？那就需要添加Operation之间的依赖：addDependency(op: )
let taskA = TaskAOperation()
let taskB = TaskBOperation()
let taskC = TaskCOperation()
///B依赖A
taskB.addDependency(op: taskA)
///C依赖B
taskC.addDependency(op: taskB)
这部分知识点还是很简单的。不过在使用时要注意死锁的问题:
op3依赖op2，op2依赖op5，op5依赖op3，这样谁也不能执行，造成死锁。所以不要造成循环依赖。
Cancel Operation
这里再讲一下，cancel并不是一种状态，而是意味着一系列动作：
判断是否应该抛出异常
清理一些垃圾数据
暂停网络请求
发送消息通知其他模块网络请求暂停
-
数据是否正确
一旦上述检查执行完毕，Operation即刻进入finished状态，所以
start()方法中才会有这么一句if isCancelled { state = .finished return }override func start() { if isCancelled { state = .finished return } main() state = .executing } override func cancel() { super.cancel() networdTask.cancel() state = .finished }此外，在main()函数中，如果有很多耗时操作，需要多次检查
isCanceledoverride func main() { ... //耗时操作1 taskOne() guard !isCancelled else { return } //耗时操作2 taskTwo() guard !isCancelled else { return } //耗时操作3 taskThree() guard !isCancelled else { return } }
Debug并发问题：Thread Sanitizer
Xcode支持多线程debug插件,比如Address Sanitizer 和 Main Thread Checker ，我们要做的是在Xcode中打开它。
点击"Scheme" ->"Edit Scheme"...如下图：
接下来运行你的App就可以了，这个过程是运行时的，如果遇到问题，会出现类似下图的样子：
总结
一般项目中，GCD和BlockOperation就能满足我们的需求，特殊情况下才会用到自定义Operation，我曾经用它写过一个支持断点续传的库，一时间找不到了，有时间重写一个，再跟大家聊聊，毕竟还要上班的吗。好了，希望这篇文章能对你有所帮助，如果喜欢我的文章，可以订阅一下，也可以"打赏一波"（哈哈，重点标注）。
