多线程：Operation和OperationQueue

生命周期

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

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

依赖（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再执行。

1. 添加依赖，改变操作顺序。 在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:这是栈的数据结构。

关于这两个数据结构模型（暂且不讲），因为后进的操作依赖于新进的操作，所以后进的操作要等先进的操作出队之后在执行。

这就是根据依赖改变的队列的执行顺序。

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

优先级（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：操作队列，这个操作队列负责把放入队列里的操作，按照一定顺序调度执行。