多线程：Operation和OperationQueue-CSDN博客

多线程：实现方式Operation和OperationQueue

Operation

生命周期

//都有共同特点，只读属性。
//是否准备
open var isReady: Bool { get }
//是否执行
open var isExecuting: Bool { get }
//是否取消
open var isCancelled: Bool { get }
//是否完成
open var isFinished: Bool { get }
//操作完成之后的回调
open var completionBlock: (() -> Void)?
复制代码

let operation = Operation() 此时处于Pending状态
依赖添加完会进入Ready阶段。此时操作对象会进入准备就绪状态。
优先级设置之后会进入执行阶段。queuePriority属性决定了进入准备就绪状态下的操作之间的开始执行顺序。
完成之后会finished，并且有回调。
完成之后的不能取消，取消可以在其他三个时刻。

依赖（dependency）

//添加依赖
open func addDependency(_ op: Operation)
//移除依赖
open func removeDependency(_ op: Operation)
复制代码

//1.创建队列
let queue = OperationQueue()
//2.创建操作
let op1 = BlockOperation {
    print("操作1")
}
let op2 = BlockOperation {
    print("操作2")
}
//3.添加依赖
op2.addDependency(op1)
//4.添加操作
queue.addOperation(op2)
queue.addOperation(op1)
复制代码

打印结果：

操作1
操作2
复制代码

结论是：op2依赖于op1时，不管添加操作的顺序如何，结果都是op1先执行，op2再执行。

添加依赖，改变操作顺序。 在SDWebImage中

  if (sself.executionOrder == SDWebImageDownloaderLIFOExecutionOrder) {
            // Emulate LIFO execution order by systematically adding new operations as last operation's dependency
            [sself.lastAddedOperation addDependency:operation];
            sself.lastAddedOperation = operation;
        }
复制代码

typedef NS_ENUM(NSInteger, SDWebImageDownloaderExecutionOrder) {
    /**
     * Default value. All download operations will execute in queue style (first-in-first-out).
先进先出：这是队列的数据结构
     */
    SDWebImageDownloaderFIFOExecutionOrder,

    /**
     * All download operations will execute in stack style (last-in-first-out).
后进先出：这是栈的数据结构
     */
    SDWebImageDownloaderLIFOExecutionOrder
};
复制代码

FIFO:先进先出：这是队列的数据结构。
LIFO:这是栈的数据结构。
关于这两个数据结构模型（暂且不讲），因为后进的操作依赖于新进的操作，所以后进的操作要等先进的操作出队之后在执行。
这就是根据依赖改变的队列的执行顺序。

不同队列的操作可以依赖。顺序保存不变。
不能相互依赖，会造成操作死锁。

优先级（queuePriority）

open var queuePriority: Operation.QueuePriority 默认normal

 public enum QueuePriority : Int {
        case veryLow
        case low
        case normal
        case high
        case veryHigh
    }
复制代码

NSOperation 提供了queuePriority（优先级）属性，queuePriority属性适用于同一操作队列中的操作，不适用于不同操作队列中的操作。
在SDWebImage中

if (options & SDWebImageDownloaderHighPriority) {
            operation.queuePriority = NSOperationQueuePriorityHigh;
        } else if (options & SDWebImageDownloaderLowPriority) {
            operation.queuePriority = NSOperationQueuePriorityLow;
        }
复制代码

取消操作

//取消操作
open func cancel()
复制代码

waitUntilFinished()

阻塞当前线程，直到该操作结束。可用于线程执行顺序的同步。

        print("begain")
        let opA = BlockOperation()
        opA.addExecutionBlock {
            print("操作A")
        }
        let opB = BlockOperation()
        opB.addExecutionBlock {
            print("操作B")
        }
        
        let queue = OperationQueue()
        queue.addOperations([opA,opB], waitUntilFinished: true)
        print("------")
        
        let opC = BlockOperation()
        opC.addExecutionBlock {
            print("操作C")
        }
        let opD = BlockOperation()
        opD.addExecutionBlock {
            print("操作D")
        }
        queue.addOperations([opC,opD], waitUntilFinished: true)
        print("end")
复制代码

打印结果

begain
操作A
操作B
------
操作C
操作D
end
复制代码

直到操作A、操作B完成之后，才能进行下面的操作

operation的实现类

因为operation是抽象类，所以使用的时候需要用子类或者继承operation的子类。

BlockOperation

        let opA = BlockOperation()
        opA.addExecutionBlock {
            print("操作A")
        }
复制代码

NSInvocationOperation

swfit中已经没有这个类了，只在OC中。

继承Operation

非并发：non-concurrent

main()
复制代码

必须重写main（）方法

class DownLoadOperation: Operation {
    override func main() {
    print("下载了")
    }
}
复制代码

    let opA = DownLoadOperation()
    let queue = OperationQueue()
    queue.addOperations([opA], waitUntilFinished: true)
复制代码

并发：concurrent

start()

isAsynchronous

isExecuting

isFinished
复制代码

至少这几个属性和方法重写
可以看SDWebimage封装的opeation

operation流程化

可以看出opretaion可以继承类，所以取代了代码块，更加面向对象。
opretaion的生命周期可以看出，操作更加容易控制。
依赖是逻辑流程更加清晰可控。所以流程化复杂的场景更合适。

operationQueue

operation：操作，一个任务可以当做是一个操作。例如：下载任务，上传任务，图片编解码任务，播放音视频...都可以看做是一个操作。
operationQueue：操作队列，这个操作队列负责把放入队列里的操作，按照一定顺序调度执行。

使用步骤

实例化一个操作，注意：要是operation的子类。
初始化queue
把操作添加到队列里。

maxConcurrentOperationCount：最大操作并发数。

default：是一个并发队列。
count=1：是一个串行队列。
count>1：是一个并发队列。
虽然count可以控制并发数，但不是数量越多效率越高，受限于cpu的能力，一般6~8最适合。

引用

苹果官方文档

深入浅出 iOS 并发编程