开发中经常遇到异步任务之间有依赖关系，需要对执行顺序进行调度的情况。
比如，一个页面要组合多个后端接口的数据，必须所有请求都完成后，再进行数据组装，最后刷新UI。
如果是同步任务，解决方案很简单。可以用dispatch_group，更方便的是用NSOperation的addDependency功能，让最后执行的任务依赖前面几个任务即可。
我们知道，NSOperation内部维护了一个状态机来表示内部任务的执行状态。一共有下面几个状态：
- ready
- executing
- finished
- cancelled
如果我们用addDependency给两个NSOperation设置了依赖关系，那么一个NSOperation对应的方法或block执行完毕后，会变为finished状态，这时另一个NSOperation才会执行。
如果我们能让异步任务表现得像同步任务一样，在异步任务收到回调后才变为finished状态，不就可以用addDependency来控制异步任务的执行顺序了吗？
事实上苹果在NSOperation的接口里给我们留了一个口子。看NSOperation的接口：
NS_CLASS_AVAILABLE(10_5, 2_0)
@interface NSOperation : NSObject {
@private
id _private;
int32_t _private1;
#if __LP64__
int32_t _private1b;
#endif
}
- (void)start;
- (void)main;
@property (readonly, getter=isCancelled) BOOL cancelled;
- (void)cancel;
@property (readonly, getter=isExecuting) BOOL executing;
@property (readonly, getter=isFinished) BOOL finished;
@property (readonly, getter=isConcurrent) BOOL concurrent; // To be deprecated; use and override 'asynchronous' below
@property (readonly, getter=isAsynchronous) BOOL asynchronous NS_AVAILABLE(10_8, 7_0);
@property (readonly, getter=isReady) BOOL ready;
- (void)addDependency:(NSOperation *)op;
- (void)removeDependency:(NSOperation *)op;
@property (readonly, copy) NSArray<NSOperation *> *dependencies;
typedef NS_ENUM(NSInteger, NSOperationQueuePriority) {
NSOperationQueuePriorityVeryLow = -8L,
NSOperationQueuePriorityLow = -4L,
NSOperationQueuePriorityNormal = 0,
NSOperationQueuePriorityHigh = 4,
NSOperationQueuePriorityVeryHigh = 8
};
@property NSOperationQueuePriority queuePriority;
@property (nullable, copy) void (^completionBlock)(void) NS_AVAILABLE(10_6, 4_0);
- (void)waitUntilFinished NS_AVAILABLE(10_6, 4_0);
@property double threadPriority NS_DEPRECATED(10_6, 10_10, 4_0, 8_0);
@property NSQualityOfService qualityOfService NS_AVAILABLE(10_10, 8_0);
@property (nullable, copy) NSString *name NS_AVAILABLE(10_10, 8_0);
@end
我们需要重点关注的是asynchronous属性。如果它值为true，那么这个NSOperation执行完毕后不会自动变为finished状态，需要手动设置。这正是我们想要的。
我们可以写一个NSOperation的子类，给异步任务提供一个设为finished状态的接口。
上代码：
typealias MLAsyncOperationBlock = (operation:MLAsyncOperation)->Void
class MLAsyncOperation: NSOperation {
private var ml_executing = false{
willSet {
willChangeValueForKey("isExecuting")
}
didSet {
didChangeValueForKey("isExecuting")
}
}
private var ml_finished = false{
willSet {
willChangeValueForKey("isFinished")
}
didSet {
didChangeValueForKey("isFinished")
}
}
private var block:MLAsyncOperationBlock?
override var asynchronous:Bool {
return true
}
override var concurrent:Bool {
return true
}
override var finished:Bool{
return ml_finished
}
override var executing:Bool{
return ml_executing
}
convenience init(operationBlock:MLAsyncOperationBlock) {
self.init()
block = operationBlock
}
override func start() {
if cancelled {
ml_finished = true
return
}
ml_executing = true
block?(operation: self)
}
func finishOperation(){
ml_executing = false
ml_finished = true
}
deinit{
print("operation deinited")
}
}
几个需要说明的点：
一：
NSOperation内部有一组成员变量来维护它的executing、finished这些状态，我们访问不到。但我们可以另外加一组成员变量，自己来维护这些状态。一个子类不一定要访问父类的成员变量，只要接口表现得和父类一样就行了。
二：
NSOperationQueue是通过KVO观察内部的NSOperation状态的变化，来自动管理NSOperation的执行的。我们在设置自己的ml_executing属性的时候，需要表现得像executing属性被设置了一样。也就是需要调用一下willChangeValueForKey("isExecuting")和didChangeValueForKey("isExecuting")两个方法。利用Swift属性的willSet和didSet特性，可以非常方便地实现。
finished属性同理。
三：
finishOperation这个方法，是用户在收到异步回调，任务完成后需要调用的。调用后这个operation就会变为finished状态。为了方便，我给MLAsyncOperationBlock加了一个MLAsyncOperation类型的参数，在调用内部block的时候会把self传进去。这样用户在构造任务block的时候，通过这个参数就直接可以访问到operation本身了。
来简单测试一下好不好用。
先写一个类实现一个同步方法和两个异步方法：
class TestClass {
let queue = dispatch_queue_create("TestClass_background_queue", DISPATCH_QUEUE_CONCURRENT)
func method1(){
print("method 1 begin")
for _ in 0 ... 100000 {
continue
}
print("method 1 end")
}
func asyncMethod1(done:()->Void){
print("async method 1 begin")
dispatch_async(queue) { () -> Void in
for _ in 0 ... 100000 {
continue
}
print("async method 1 end")
done()
}
return
}
func asyncMethod2(done:()->Void){
print("async method 2 begin")
dispatch_async(queue) { () -> Void in
for _ in 0 ... 100000 {
continue
}
print("async method 2 end")
done()
}
return
}
}
测试代码：
let operationQueue = NSOperationQueue()
operationQueue.maxConcurrentOperationCount = 5
let object = TestClass()
let op1 = NSBlockOperation {
object.method1()
}
let asyncOp1 = MLAsyncOperation { (operation) in
object.asyncMethod1{ () -> Void in
operation.finishOperation()
}
}
let asyncOp2 = MLAsyncOperation { (operation) in
object.asyncMethod2{
operation.finishOperation()
}
}
op1.addDependency(asyncOp1)
op1.addDependency(asyncOp2)
operationQueue.addOperation(asyncOp1)
operationQueue.addOperation(asyncOp2)
operationQueue.addOperation(op1)
let runloop = NSRunLoop.currentRunLoop()
while runloop.runMode(NSDefaultRunLoopMode, beforeDate: NSDate.distantFuture()){
continue
}
由于测试工程是一个command line tool，我用runloop阻塞住了主线程，避免主线程执行完之后整个程序退出，operationQueue中的代码来不及执行。
跑一下，输出结果如下：
async method 1 begin
async method 2 begin
async method 1 end
async method 2 end
method 1 begin
method 1 end
可以看到，两个异步方法并行执行，在两个方法都收到回调完成之后，最后一个方法开始执行。完美实现了我们的需求。
完整的代码可以从我的Github下载。
