Swift并发编程（二）Operation

书接上回，GCD提供了实现并发的大多数功能。可对于一些高度定制化的，可复用性极高的代码，GCD显得有点啰嗦。总不能遇到一次，写一次吧？那么今天来我们就来聊聊Operation。

Operation基本介绍

与GCD相比，Operation更具有封装的，重用的特性，我们可以将一些逻辑独立，可重用性高的代码封装到Operation中。Operation的生命周期是通过状态机控制的，如下图：

operation_state.png

• 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)

这部分知识点还是很简单的。不过在使用时要注意死锁的问题:

dead_lock.png

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()函数中，如果有很多耗时操作，需要多次检查isCanceled

  override 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"...如下图：

sheme.png

open.png

接下来运行你的App就可以了，这个过程是运行时的，如果遇到问题，会出现类似下图的样子：

issue.png

总结

一般项目中，GCD和BlockOperation就能满足我们的需求，特殊情况下才会用到自定义Operation，我曾经用它写过一个支持断点续传的库，一时间找不到了，有时间重写一个，再跟大家聊聊，毕竟还要上班的吗。好了，希望这篇文章能对你有所帮助，如果喜欢我的文章，可以订阅一下，也可以"打赏一波"（哈哈，重点标注）。