多线程：实现方式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
operationQueue：操作队列，这个操作队列负责把放入队列里的操作，按照一定顺序调度执行。
使用步骤
- 实例化一个操作，注意：要是operation的子类。
- 初始化queue
- 把操作添加到队列里。
maxConcurrentOperationCount：最大操作并发数。
- default：是一个并发队列。
- count=1：是一个串行队列。
- count>1：是一个并发队列。
虽然count可以控制并发数，但不是数量越多效率越高，受限于cpu的能力，一般6~8最适合。
引用
