上一篇文章为大家简单介绍了NSThread与GCD，并且还对它们进行了一个简单的比对，本篇文章将着重介绍NSOperation与NSOperationQueue，如果有写的不对的地方欢迎大家拍砖或者交流。

NSOperation与GCD

如标题，GCD与NSOperation是iOS目前比较先进也比较好用的两套多线程的API。先对二者做一个比较：

• GCD：是基于C的底层而实现的，是一种轻量级的多线程变成的API，不需要计划任务单位，但是对于线程之间添加依赖关系会比较繁杂。
• NSOperation：NSOperation是基于GCD实现的，是对GCD的一种封装，当然也就比GCD多了一些系统开销，但是可以在多个操作中添加附属，可以重用、暂停或者取消，可以轻易实现一些GCD需要花费大量代码去完成的事情。
  以上是二者之间最本质的区别，当然实际使用需要看各自的应用场景，并不是越高级别抽象的越好。
  相比较于GCD，NSOperation实现多线程就需要稍微多一些步骤。GCD的任务都可以写在其block中，没有太过复杂的操作，但是对于线程暂停等操作，GCD实现起来会比较麻烦。
  而NSOperation实现多线的步骤是这样的：
• 把需要执行的操作封装到一个NSOperation对象中
• 把NSOperation对象添加到NSOperationQueue中
• 系统自动提取NSOperation与NSOperationQueue
• 将提取出来的NSOperation封装的操作放到一条新的线程中执行

NSOperation

NSOperation是一个抽象类，不能够封装操作，只能通过以下三种方式来实现封装操作：

• NSInvocationOperation
• NSBlockOperation
• 自定义子类继承NSOperation，实现内部的相应方法（重写main或start方法来定义自己的operation）

NSInvocationOperation

//创建NSInvocationOperation对象
    NSInvocationOperation *invoOperation = [[NSInvocationOperation alloc]initWithTarget:self selector:@selector(doSomeThing) object:nil];

//调用start方法来执行操作
    [invoOperation start];

NSInvocationOperation比较简单，继承了NSOperation，它是基于一个对象和selector来创建操作，可以直接使用而不需继承来实现自己的操作处理。并且默认情况下，调用了start方法之后不会开一条新线程去操作，是在当前线程下同步执行操作，只有将其放到NSOperationQueue中才会执行异步操作。

NSBlockOperation

//创建NSBlockOperation对象
    NSBlockOperation *blockOperation1 = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"create1----%@",[NSThread currentThread]);
    }];

    //通过addExecutionBlock:方法添加更多的操作
    [blockOperation1 addExecutionBlock:^{
        NSLog(@"add1-----%@",[NSThread currentThread]);
    }];
    
    [blockOperation1 addExecutionBlock:^{
        NSLog(@"add2-----%@",[NSThread currentThread]);
    }];

    //创建NSBlockOperation对象
    NSBlockOperation *blockOperation2 = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"create2----%@",[NSThread currentThread]);
    }];
    
    [blockOperation2 addExecutionBlock:^{
        NSLog(@"add2--1-----%@",[NSThread currentThread]);
    }];
    
    [blockOperation2 addExecutionBlock:^{
        NSLog(@"add2--2-----%@",[NSThread currentThread]);
    }];
    
    [blockOperation1 start];
    [blockOperation2 start];

打印结果：

NSBlockOperation.png

可以看出NSBlockOperation如果封装了多个操作，那么除了第一个操作外，其他的操作会在子线程中进行。如果只封装了一个操作，默认在主线程中进行，并且只要NSBlockOperation封装的操作数大于一个，就会异步执行操作。

NSOperationQueue

NSOperationQueue可以通过alloc/init来自己创建，默认是并发执行，也可以让它串行。如果将NSOperation添加到NSOperationQueue中，系统会自动异步执行NSOperation中的操作。可以将NSOperationQueue看作是一个线程池，可以向其中添加操作。

NSBlockOperation *blockOperation1 = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"create1----%@",[NSThread currentThread]);
    }];
    
    NSBlockOperation *blockOperation2 = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"create2----%@",[NSThread currentThread]);
    }];
    
    NSBlockOperation *blockOperation3 = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"create3----%@",[NSThread currentThread]);
    }];
    
    NSOperationQueue *myQueue = [[NSOperationQueue alloc]init];
    //设置队列名字
    myQueue.name = @"MyQueue";
    //设置最大并发数量(同事开3个线程执行3个任务)
    myQueue.maxConcurrentOperationCount = 3;
    
    //添加操作到NSOperationQueue
    [myQueue addOperation:blockOperation1];
    [myQueue addOperation:blockOperation2];
    [myQueue addOperation:blockOperation3];
    [myQueue addOperationWithBlock:^{
        NSLog(@"create4----%@",[NSThread currentThread]);
    }];

最大并发操作数量：
队列中最多同时运行几条线程。虽然NSOperationQueue类设计用于并发执行Operations,你也可以强制单个queue一次只能执行一个Operation。setMaxConcurrentOperationCount:方法可以配置queue的最大并发操作数量。设为1就表示queue每次只能执行一个操作。不过operation执行的顺序仍然依赖于其它因素,比如operation是否准备好和operation的优先级等。因此串行化的operation queue并不等同于GCD中的串行dispatch queue
执行两次打印结果：

NSOperationQueue.png

队列的相关操作

取消

//取消队列的所有操作
[myQueue cancelAllOperations];

打印结果：无打印
//取消某一个操作

 [blockOperation2 cancel];

打印结果:

cancel.png

暂停和恢复

//YES代表暂停队列，NO代表恢复队列
if (a % 2 == 0) {
        [myQueue setSuspended:YES];
        //或
        //myQueue.isSuspended = YES;
    }else{
        [myQueue setSuspended:NO];
    }

操作依赖

NSOperation之间可以设置依赖来保证执行顺序，当某个NSOperation对象依赖于其他NSOperation对象的时候，就可以通过addDependency方法添加一个或多个依赖对象，只有所有依赖的对象完成操作之后，当前的NSOperation对象才会开始操作，还可以通过removeDependency来删除依赖对象。

NSBlockOperation *blockOperation1 = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"create1----%@",[NSThread currentThread]);
    }];
    
    NSBlockOperation *blockOperation2 = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"create2----%@",[NSThread currentThread]);
    }];
    
    NSBlockOperation *blockOperation3 = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"create3----%@",[NSThread currentThread]);
    }];
    
    NSOperationQueue *myQueue = [[NSOperationQueue alloc]init];
    //设置队列名字
    myQueue.name = @"MyQueue";
    //设置最大并发数量
    myQueue.maxConcurrentOperationCount = 3;
    
    //添加操作依赖
    [blockOperation1 addDependency:blockOperation2];
    [blockOperation3 addDependency:blockOperation1];
    
    //添加操作到NSOperationQueue
    [myQueue addOperation:blockOperation1];
    [myQueue addOperation:blockOperation2];
    [myQueue addOperation:blockOperation3];

打印结果：

操作依赖.png

可以看出，先执行blockOperation2，再执行blockOperation1，最后执行blockOperation3。
注意：
对于添加到queue中的操作，它的执行顺序取决于两点：

• 首先是NSOperation是否准备好，是否准备好是由对象的依赖关系来决定。
• 之后再根据NSOperation的相对优先级来决定，默认都是普通的优先级，可以通过setQueuePriority来设置优先级。优先级不能替代依赖关系，优先级是针对于已经准备好的NSOperation来确定执行顺序，先满足依赖关系，再根据优先级从所有准备好的操作中选择执行优先级最高的那个。

NSBlockOperation *blockOperation1 = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"create1----%@",[NSThread currentThread]);
    }];
    
    NSBlockOperation *blockOperation2 = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"create2----%@",[NSThread currentThread]);
    }];
    
    NSBlockOperation *blockOperation3 = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"create3----%@",[NSThread currentThread]);
    }];
NSBlockOperation *blockOperation4 = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"create4----%@",[NSThread currentThread]);
    }];
    [blockOperation4 setQueuePriority:NSOperationQueuePriorityVeryHigh];
//添加操作依赖
    [blockOperation1 addDependency:blockOperation2];
    [blockOperation3 addDependency:blockOperation1];
    [blockOperation4 addDependency:blockOperation2];

    [myQueue addOperation:blockOperation1];
    [myQueue addOperation:blockOperation2];
    [myQueue addOperation:blockOperation3];
    [myQueue addOperation:blockOperation4];

运行两遍打印结果：

依赖优先级.png

由结果可见，先满足依赖关系，才根据优先级从所有准备好的操作中选择优先级高的执行

//优先级:
typedef NS_ENUM(NSInteger, NSOperationQueuePriority) {
    NSOperationQueuePriorityVeryLow = -8L,
    NSOperationQueuePriorityLow = -4L,
    NSOperationQueuePriorityNormal = 0,
    NSOperationQueuePriorityHigh = 4,
    NSOperationQueuePriorityVeryHigh = 8
};

自定义NSOperation

自定义NSOperation可以通过重写 main 或者start方法 来定义自己的 operations 。
使用 main方法非常简单，开发者不需要管理一些状态属性（例如 isExecuting 和 isFinished），当 main 方法返回的时候，这个 operation 就结束了。这种方式使用起来非常简单，但是灵活性相对重写 start 来说要少一些， 因为main方法执行完就认为operation结束了，所以一般可以用来执行同步任务。
重写main方法有一个注意点：

• 需要自己创建自动释放池（如果是异步操作，无法访问主线程的自动释放池）
• 为了能使用操作队列所提供的取消功能，你需要在长时间操作中时不时地检查 isCancelled属性
  以上是对NSOperation与NSOperationQueue的一点简单介绍，如果有哪里不对的地方欢迎拍砖交流。