三、Swift中的Operation

Cocoa Operation不需要关心线程管理和数据同步的事情，可以把精力放在自己需要执行的操作上。相关的类有Operation和OperationQueue。其中Operation是个抽象类，使用它必须用它的子类，可以实现它或者使用它定义好的子类：BlockOperation。创建Operation子类的对象，把对象添加到OperationQueue队列里执行

Operation头文件

@available(iOS 2.0, *)
open class Operation : NSObject {
    open func start()
    open func main()
    open var isCancelled: Bool { get }
    open func cancel()
    open var isExecuting: Bool { get }
    open var isFinished: Bool { get }
    open var isConcurrent: Bool { get }
    @available(iOS 7.0, *)
    open var isAsynchronous: Bool { get }
    open var isReady: Bool { get }
    open func addDependency(_ op: Operation)
    open func removeDependency(_ op: Operation)   
    open var dependencies: [Operation] { get }
    open var queuePriority: Operation.QueuePriority 
    @available(iOS 4.0, *)
    open var completionBlock: (() -> Swift.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?
extension Operation {
    public enum QueuePriority : Int {
        case veryLow
        case low
        case normal
        case high
        case veryHigh
@available(iOS 4.0, *)
open class BlockOperation : Operation {    
    public convenience init(block: @escaping () -> Swift.Void)
    open func addExecutionBlock(_ block: @escaping () -> Swift.Void)
    open var executionBlocks: [() -> Swift.Void] { get }
extension NSExceptionName {
    @available(iOS 2.0, *)
    public static let invocationOperationVoidResultException: NSExceptionName
    @available(iOS 2.0, *)
    public static let invocationOperationCancelledException: NSExceptionName
常用属性和方法
开启&取消操作方法
open func start();   执行并发任务的入口
open func cancel();  可取消操作，实质是标记 isCancelled 状态。
open func main();    执行非并发任务的入口
open var threadPriority: Double; 指定优先级
open var qualityOfService: QualityOfService; 指定特殊服务质量等级   
判断操作状态方法

open var isFinished: Bool { get }; 判断操作是否已经结束,即正常运行结束。。
open var isCancelled: Bool { get }; 判断操作是否已经标记为取消,如果cancel()方法被调用，那么Operation实例就会切换到这个状态。
open var isExecuting: Bool { get }; 判断操作是否正在在运行,发生在调用start()方法之后。
open var isReady: Bool { get }; 判断操作是否处于准备就绪状态，这个值和操作的依赖关系相关。
open func waitUntilFinished(); 阻塞当前线程，直到该操作结束。可用于线程执行顺序的同步。
open var completionBlock: (() -> Swift.Void)?; completionBlock 会在当前操作执行完毕时执行 completionBlock。
open func addDependency(_ op: Operation); 添加依赖，使当前操作依赖于操作 op 的完成。
open func removeDependency(_ op: Operation); 移除依赖，取消当前操作对操作 op 的依赖。
open var dependencies: [Operation] { get }; 在当前操作开始执行之前完成执行的所有操作对象数组。
@available(iOS 2.0, *)
open class OperationQueue : NSObject {
    open func addOperation(_ op: Operation)
    @available(iOS 4.0, *)
    open func addOperations(_ ops: [Operation], waitUntilFinished wait: Bool)
    @available(iOS 4.0, *)
    open func addOperation(_ block: @escaping () -> Swift.Void)   
    open var operations: [Operation] { get }
    @available(iOS 4.0, *)
    open var operationCount: Int { get }
    open var maxConcurrentOperationCount: Int 
    open var isSuspended: Bool   
    @available(iOS 4.0, *)
    open var name: String?    
    @available(iOS 8.0, *)
    open var qualityOfService: QualityOfService
    @available(iOS 8.0, *)
    unowned(unsafe) open var underlyingQueue: DispatchQueue?  
    open func cancelAllOperations()    
    open func waitUntilAllOperationsAreFinished()
    @available(iOS 4.0, *)
    open class var current: OperationQueue? { get }
    @available(iOS 4.0, *)
    open class var main: OperationQueue { get }
常用属性和方法

取消/暂停/恢复操作

open func cancelAllOperations(); 可以取消队列的所有操作。
open var isSuspended: Bool; {get}判断队列是否处于暂停状态。 YES 为暂停状态，NO 为恢复状态。
open var isSuspended: Bool; {set}可设置操作的暂停和恢复，YES 代表暂停队，NO 为恢复状态。   
open func waitUntilAllOperationsAreFinished(); 阻塞当前线程，直到队列中的操作全部执行完毕。   
添加/获取操作`

open func addOperation(_ block: @escaping () -> Swift.Void); 向队列中添加一个 BlockOperation 类型操作对象。
open func addOperations(_ ops: [Operation], waitUntilFinished wait: Bool); 向队列中添加操作数组，wait 标志是否阻塞当前线程直到所有操作结束
open var operations: [Operation] { get }; 当前在队列中的操作数组（某个操作执行结束后会自动从这个数组清除）。
open var operationCount: Int { get }; 当前队列中的操作数。
open var maxConcurrentOperationCount: Int; 最大并发数
open var qualityOfService: QualityOfService； 优先级   
open class var current: OperationQueue? { get }; 获取当前队列，如果当前线程不是在 NSOperationQueue 上运行则返回 nil。
open class var main: OperationQueue { get }; 获取主队列。   
这里的暂停和取消（包括操作的取消和队列的取消）并不代表可以将当前的操作立即取消，而是当当前的操作执行完毕之后不再执行新的操作。暂停和取消的区别就在于：暂停操作之后还可以恢复操作，继续向下执行；而取消操作之后，所有的操作就清空了，无法再接着执行剩下的操作。
任务二:<NSThread: 0x600003ee8900>{number = 6, name = (null)}
任务一:<NSThread: 0x600003ead6c0>{number = 7, name = (null)}
任务三:<NSThread: 0x600003ea4900>{number = 1, name = main}
1. BlockOperation 还提供了一个方法 addExecutionBlock，通过 addExecutionBlock: 就可以为 BlockOperation 添加额外的操作。这些操作（包括 blockOperationWithBlock 中的操作）可以在不同的线程中同时（并发）执行。只有当所有相关的操作已经完成执行时，才视为完成。

对于非并发的操作，在子类的Operation中，只需要复写main()就可以了。
在main()方法中，写一些任务执行的代码等，另外在子类中可能还需要写一些初始化方法，以及一些访问读取数据的方法等等。
至于Operation的几种状态，我们是不需要关心的，当main()方法执行完毕，即Operation任务结束。
Operation类中还提供了cancel()的方法，所以在Operation执行的时候需要判断是否已经取消了，因为取消操作可能在开始之前就执行了，也可能在任务执行过程中，所以代码中需要加入isCancelled的判断。
    override func viewDidLoad() {
        super.viewDidLoad()
        let op = MyOpertaion(data: "自定义Operation")
        op.start()
class MyOpertaion: Operation {
    var data: Any?
    init(data: Any) {
        super.init()
        self.data = data
    override func main() {
        var isDone = false
        while !isCancelled && !isDone {
            // 在此方法中做一些相关业务操作等，并在完成后将isDone设置为true
            print("自定义Operation:\(Thread.current)")
            // ......
            isDone = true
自定义Operation:<NSThread: 0x6000030781c0>{number = 1, name = main}
并发Operation
Operation对象默认以同步方式执行，也就是说，在调用start方法的线程中执行任务。但是，由于OperationQueue为非并发操作提供线程，所以大多数Operation仍然是异步运行的。但是，如果我们手动使用Operation，不用OperationQueue，并且仍然希望它们异步运行，则必须采取适当的操作来确保能够做到这一点。我们可以通过将Operation对象定义为并发操作来实现这一点。至于并发的Operation，稍微有些复杂了，因为这里面的状态需要开发人员来管控。
如果创建一个并发的Operation，则至少需要复写以下的方法或属性：
需要重写的属性
override var isExecuting: Bool{
    return _executing
override var isFinished: Bool{
    return _finished
override var isAsynchronous: Bool{
    return true
利用KVO来通知Operation的isExecuting（是否正在进行中），以及isFinished（是否已经完成）
//指定用于记录任务是否执行
private var _executing:Bool = false{
    //kvo isExecuting
    willSet{
        willChangeValue(forKey: ModifyState.isExecuting.rawValue)
    didSet{
        didChangeValue(forKey: ModifyState.isExecuting.rawValue)
//指定用于记录任务是否完成




    

private var _finished:Bool = false{
    //kvo isFinished
    willSet{
        willChangeValue(forKey: ModifyState.isFinished.rawValue)
    didSet{
        didChangeValue(forKey: ModifyState.isFinished.rawValue)
/// 修改状态枚举(重写状态的字段标识)
private enum ModifyState: String{
    case isExecuting = "isExecuting"
    case isFinished = "isFinished"
重写start方法，开辟新的线程执行需要的耗时工作。注意：不能调用父类的start方法。
因为Operation有cancel方法来取消操作，而且我们并不知道在何时取消，所以我们需要在几个地方注意是否取消了操作.
进入start方法时
执行耗时的任务后
override func start() {
    //检测取消状态
    if isCancelled {
        done()
        return
    //修改状态->执行
    _executing = true
    //开启任务->并行,完成回调测试
    startTask()
//开启任务(模拟耗时任务)
private func startTask(){
    DispatchQueue.global().async { [weak self] in
        print("线程:",Thread.current)
        //耗时
        sleep(2)
        for i in 0...2{
            print("\(i)")
        //检测状态
        if self?.isCancelled ?? false{
            self?.done()
            return
        DispatchQueue.main.async { [weak self] in
            //完成
            self?.completedBlock?(true)
            self?.done()
        let mainQueue = OperationQueue.main
        let operation1 = BlockOperation {
            print("任务一:\(Thread.current)")
        let opertaion2 = BlockOperation {
            print("任务二:\(Thread.current)")
        let opertaion3 = BlockOperation {
            print("任务三:\(Thread.current)")
        let opertaion4 = BlockOperation {
            print("任务四:\(Thread.current)")
        mainQueue.addOperation(operation1)
        mainQueue.addOperation(opertaion2)
        mainQueue.addOperation(opertaion3)
        mainQueue.addOperation(opertaion4)
任务一:<NSThread: 0x6000009bc280>{number = 1, name = main}
任务二:<NSThread: 0x6000009bc280>{number = 1, name = main}
任务三:<NSThread: 0x6000009bc280>{number = 1, name = main}
任务四:<NSThread: 0x6000009bc280>{number = 1, name = main}
        queue.maxConcurrentOperationCount = 4
        let operation1 = BlockOperation {
            print("任务一 = \(Thread.current)")
        let operation2 = BlockOperation {
            print("任务二 = \(Thread.current)")
        let operation3 = BlockOperation {
            print("任务三 = \(Thread.current)")
        let operation4 = BlockOperation {
            print("任务四 = \(Thread.current)")
        queue.addOperation(operation1)
        queue.addOperation(operation2)
        queue.addOperation(operation3)
        queue.addOperation(operation4)
任务三 = <NSThread: 0x600000bd6980>{number = 4, name = (null)}
任务二 = <NSThread: 0x600000ba1dc0>{number = 7, name = (null)}
任务一 = <NSThread: 0x600000bf6500>{number = 6, name = (null)}
任务四 = <NSThread: 0x600000bf7100>{number = 5, name = (null)}
六. OperationQueue 控制串行执行、并发执行
　　最大并发操作数：maxConcurrentOperationCount
maxConcurrentOperationCount 默认情况下为-1，表示不进行限制，可进行并发执行。
maxConcurrentOperationCount 为1时，队列为串行队列。只能串行执行。
class ViewController: UIViewController {
    override func viewDidLoad() {
        super.viewDidLoad()
        print("start")
        let queue = OperationQueue()
        queue.maxConcurrentOperationCount = 1; // 串行队列
        queue.addOperation {
            sleep(2)
            print("0---\(Date())\(Thread.current)")
        queue.addOperation {
            sleep(2)
            print("1---\(Date())\(Thread.current)")
        let operation1 = BlockOperation.init {
            sleep(2)
            print("2---\(Date())\(Thread.current)")
        operation1.addExecutionBlock {
            sleep(2)
            print("3---\(Date())\(Thread.current)")
        queue.addOperation(operation1)
        print("end")
start
0---2021-07-21 08:30:46 +0000<NSThread: 0x600003f23140>{number = 6, name = (null)}
1---2021-07-21 08:30:48 +0000<NSThread: 0x600003f2d540>{number = 5, name = (null)}
2---2021-07-21 08:30:50 +0000<NSThread: 0x600003f23140>{number = 6, name = (null)}
3---2021-07-21 08:30:50 +0000<NSThread: 0x600003f2d540>{number = 5, name = (null)}
maxConcurrentOperationCount 大于1时，队列为并发队列。操作并发执行，当然这个值不应超过系统限制，即使自己设置一个很大的值，系统也会自动调整为 min{自己设定的值，系统设定的默认最大值}。
class ViewController: UIViewController {
    override func viewDidLoad() {
        super.viewDidLoad()
        print("start")
        let queue = OperationQueue()
        queue.maxConcurrentOperationCount = 4; // 串行队列
        queue.addOperation {
            sleep(2)
            print("0---\(Date())\(Thread.current)")
        queue.addOperation {
            sleep(2)
            print("1---\(Date())\(Thread.current)")
        let operation1 = BlockOperation.init {
            sleep(2)
            print("2---\(Date())\(Thread.current)")
        operation1.addExecutionBlock {
            sleep(2)
            print("3---\(Date())\(Thread.current)")
        queue.addOperation(operation1)
        print("end")
start
0---2021-07-21 08:33:23 +0000<NSThread: 0x600001aa89c0>{number = 2, name = (null)}
1---2021-07-21 08:33:23 +0000<NSThread: 0x600001aace00>{number = 6, name = (null)}
2---2021-07-21 08:33:23 +0000<NSThread: 0x600001aa07c0>{number = 4, name = (null)}
3---2021-07-21 08:33:23 +0000<NSThread: 0x600001aa85c0>{number = 3, name = (null)}
七. Operation 操作依赖
　　Operation、OperationQueue 最吸引人的地方是它能添加操作之间的依赖关系。通过操作依赖，我们可以很方便的控制操作之间的执行先后顺序。Operation 提供了3个接口供我们管理和查看依赖。
func addDependency(_ op: Operation); 添加依赖，使当前操作依赖于操作 op 的完成。
class ViewController: UIViewController {
    override func viewDidLoad() {
        super.viewDidLoad()
        testDependency()
    //测试op依赖关系
    //A,B - C
    //C,D - E
    func testDependency(){
        let opA = BlockOperation()
        let opB = BlockOperation()
        let opC = BlockOperation()
        let opD = BlockOperation()
        let opE = BlockOperation()
        ///创建任务
        opA.addExecutionBlock {
            for i in 0...10{
                if i == 10{
                    print("A--\(i)")
        opB.addExecutionBlock {
            for i in 0...10{
                if i == 10{
                    print("B--\(i)")
        opC.addExecutionBlock {
            for i in 0...10{
                if i == 10{
                    print("C--\(i)")
        opD.addExecutionBlock {
            for i in 0...10{
                if i == 10{
                    print("D--\(i)")
        opE.addExecutionBlock {
            for i in 0...10{
                if i == 10{
                    print("E--\(i)")
        ///添加依赖
        opC.addDependency(opA)
        opC.addDependency(opB)
        opE.addDependency(opC)
        opE.addDependency(opD)
        let queue = OperationQueue()
        queue.maxConcurrentOperationCount = 6
        queue.addOperations([opA,opB,opC,opD,opE], waitUntilFinished: false)
        print("end")
func removeDependency(_ op: Operation); 移除依赖，取消当前操作对操作 op 的依赖。
var dependencies: [Operation] { get }; 在当前操作开始执行之前完成执行的所有操作对象数组。
　　小心死锁: 如果Operation之间互相依赖，比如队列A中的Operation1依赖Operation2, 而Operation2依赖Operation3，Operation3依赖Operation1, 这就会陷入互相等待的死锁。
八. Operation 优先级
　　Operation 提供了queuePriority（优先级）属性，queuePriority属性适用于同一操作队列中的操作，不适用于不同操作队列中的操作。默认情况下，所有新创建的操作对象优先级都是normal。但是我们可以通过setQueuePriority:方法来改变当前操作在同一队列中的执行优先级。
// 优先级的取值

 public enum QueuePriority : Int {
        　　case veryLow = -8
        　　case low = -4
        　　case normal = 0
        　　case high = 4
        　　case veryHigh = 8
    }
　　上边我们说过：对于添加到队列中的操作，首先进入准备就绪的状态（就绪状态取决于操作之间的依赖关系），然后进入就绪状态的操作的开始执行顺序（非结束执行顺序）由操作之间相对的优先级决定（优先级是操作对象自身的属性）。 
　　那么，什么样的操作才是进入就绪状态的操作呢？
　　当一个操作的所有依赖都已经完成时，操作对象通常会进入准备就绪状态，等待执行。
　　
　　举个例子，现在有4个优先级都是 normal（默认级别）的操作：op1，op2，op3，op4。其中 op3 依赖于 op2，op2 依赖于 op1，即 op3 -> op2 -> op1。现在将这4个操作添加到队列中并发执行。
因为 op1 和 op4 都没有需要依赖的操作，所以在 op1，op4 执行之前，就是处于准备就绪状态的操作。
而 op3 和 op2 都有依赖的操作（op3 依赖于 op2，op2 依赖于 op1），所以 op3 和 op2 都不是准备就绪状态下的操作。理解了进入就绪状态的操作，那么我们就理解了queuePriority 属性的作用对象。
queuePriority 属性决定了进入准备就绪状态下的操作之间的开始执行顺序。并且，优先级不能取代依赖关系。
如果一个队列中既包含高优先级操作，又包含低优先级操作，并且两个操作都已经准备就绪，那么队列先执行高优先级操作。比如上例中，如果 op1 和 op4 是不同优先级的操作，那么就会先执行优先级高的操作。
如果，一个队列中既包含了准备就绪状态的操作，又包含了未准备就绪的操作，未准备就绪的操作优先级比准备就绪的操作优先级高。那么，虽然准备就绪的操作优先级低，也会优先执行。优先级不能取代依赖关系。如果要控制操作间的启动顺序，则必须使用依赖关系。
        opC.queuePriority = .normal
        let queue = OperationQueue()
        queue.maxConcurrentOperationCount = 3
        queue.addOperations([opA, opB, opC], waitUntilFinished: false)
九. Operation、OperationQueue 线程间的通信
　　在 iOS 开发过程中，我们一般在主线程里边进行 UI 刷新，例如：点击、滚动、拖拽等事件。我们通常把一些耗时的操作放在其他线程，比如说图片下载、文件上传等耗时操作。而当我们有时候在其他线程完成了耗时操作时，需要回到主线程，那么就用到了线程之间的通讯。
class ViewController: UIViewController {
    override func viewDidLoad() {
        super.viewDidLoad()
        communication()
    ///线程间通信
    func communication() {
        OperationQueue().addOperation {
            sleep(2)
            print("1---\(Date())\(Thread.current)")
            OperationQueue.main.addOperation({
                sleep(2)
                print("2---\(Date())\(Thread.current)")
　　可以看到：通过线程间的通信，先在其他线程中执行操作，等操作执行完了之后再回到主线程执行主线程的相应操作。
十. Operation、OperationQueue 线程同步和线程安全
线程同步：
可理解为线程 A 和 线程 B 一块配合，A 执行到一定程度时要依靠线程 B 的某个结果，于是停下来，示意 B 运行；B 依言执行，再将结果给 A；A 再继续操作。
若每个线程中对全局变量、静态变量只有读操作，而无写操作，一般来说，这个全局变量是线程安全的；若有多个线程同时执行写操作（更改变量），一般都需要考虑线程同步，否则的话就可能影响线程安全。
线程安全：
如果你的代码所在的进程中有多个线程在同时运行，而这些线程可能会同时运行这段代码。如果每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。
线程安全解决方案：
可以给线程加锁，在一个线程执行该操作的时候，不允许其他线程进行操作。iOS 实现线程加锁有很多种方式。@synchronized、 NSLock、NSRecursiveLock、NSCondition、NSConditionLock、pthread_mutex、dispatch_semaphore、OSSpinLock、atomic(property) set/ge等等各种方式。这里我们使用 NSLock 对象来解决线程同步问题。NSLock 对象可以通过进入锁时调用 lock 方法，解锁时调用 unlock 方法来保证线程安全。
考虑线程安全的代码：

class ViewController: UIViewController {
    var ticketSurplusCount = 50
    override func viewDidLoad() {
        super.viewDidLoad()
        ///1.1 创建代表北京火车票售卖窗口
        let operationForBeiJing = OperationQueue()
        operationForBeiJing.maxConcurrentOperationCount = 1;
        ///1.2 创建卖票操作 op1
        let op1 = BlockOperation{ 
            self.saleTicketSafe()
        ///1.3 添加操作
        operationForBeiJing.addOperation(op1)
        ///2.1创建代表上海火车票售卖窗口
        let operationForShangHai = OperationQueue()
        operationForShangHai.maxConcurrentOperationCount = 1;
        ///2.2创建卖票操作 op2
        let op2 = BlockOperation{
            self.saleTicketSafe()
        ///2.3 添加操作
        operationForShangHai.addOperation(op2)
    private func saleTicketSafe(){
        while true {
            objc_sync_enter(self)
            if self.ticketSurplusCount > 0 {
                self.ticketSurplusCount-=1;
                print("剩余票数:\(self.ticketSurplusCount) 窗口:\(Thread.current)")
                sleep(2)
            objc_sync_exit(self)
            if self.ticketSurplusCount <= 0 {
                print("所有火车票均已售完")
                break