NSOperation

1.简单了解

先来了解一下串行和并行

• 串行和并行描述的是任务和任务之间的执行方式
• 串行是任务A执行完了任务B才执行
• 并行则是任务A和任务B可以同时执行

同步和异步

• 同步和异步描述的是函数什么时候返回

NSOperation、NSOperationQueue 是基于 GCD 更高一层的封装，完全面向对象。但是比 GCD 更简单易用、代码可读性也更高。

NSOperation：
指代的是操作，是一个抽象类。使用必须子类化 NSInvocationOperation 和 NSBlockOperation，或者自定义子类。它只执行一次任务，不能用于再次执行它。
如果一个操作仍然依赖于尚未完成的其他操作，则认为该操作尚未准备好执行，也就是没有变成ready状态。

操作队列（Operation Queues）：
这里的队列指操作队列，即用来存放操作的队列。不同于 GCD 中的调度队列 FIFO（先进先出）的原则。NSOperationQueue 对于添加到队列中的操作，首先进入准备就绪的状态（就绪状态取决于操作之间的依赖关系），然后进入就绪状态的操作的开始执行顺序（非结束执行顺序）由操作之间相对的优先级决定（优先级是操作对象自身的属性）。

操作队列通过设置最大并发操作数（maxConcurrentOperationCount）来控制并发、串行。
NSOperationQueue 为我们提供了两种不同类型的队列：主队列和自定义队列。主队列运行在主线程之上，而自定义队列在后台执行。

2. NSOpeartion

NSOperation 是个抽象类，不能用来封装操作。我们只有使用它的子类来封装操作。我们有三种方式来封装操作。

• 使用子类 NSInvocationOperation
• 使用子类 NSBlockOperation
• 自定义继承自 NSOperation 的子类，通过实现内部相应的方法来封装操作。

NSOperation属性和方法

- (void)start; 开始执行操作。会执行若干检查，以确保操作可以实际运行。例如，如果接收器被cancel或已经finished，这个方法只返回而不调用main。
- (void)cancel; 可取消操作，实质是标记 isCancelled 状态。此方法不会强制停止操作代码。相反，它更新对象的内部标志来反映状态的变化。

- (void)main; 继承NSOperation的子类，可以在main方法中写任务代码。

- (BOOL)isFinished; 判断操作是否已经结束。
- (BOOL)isCancelled; 判断操作是否已经标记为取消。
- (BOOL)isExecuting; 判断操作是否正在在运行。
- (BOOL)isReady; 判断操作是否处于准备就绪状态，这个值和操作的依赖关系相关。

- (void)waitUntilFinished; 会阻塞当前线程，直到该操作结束。可用于线程执行顺序的同步。
- (void)setCompletionBlock:(void (^)(void))block; completionBlock 会在当前操作执行完毕时执行 completionBlock。
- (void)addDependency:(NSOperation *)op; 添加依赖，使当前操作依赖于操作 op 的完成。
- (void)removeDependency:(NSOperation *)op; 移除依赖，取消当前操作对操作 op 的依赖。
@property (readonly, copy) NSArray<NSOperation *> *dependencies; 在当前操作开始执行之前完成执行的所有操作对象数组。

注意：在不使用 NSOperationQueue，单独使用 NSOperation 的情况下系统同步执行操作，下面我们学习以下操作的三种创建方式。

2.1 NSInvocationOperation

#import "ViewController.h"

@interface ViewController ()

@property (nonatomic, strong) NSInvocationOperation *invocationOperation;

@end

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    
    _invocationOperation = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(invocationOperationStart) object:nil];
    [_invocationOperation start];
}

- (void)invocationOperationStart{
    for (NSInteger i = 0; i < 6; i++) {
        sleep(1);
        NSLog(@"currentThread - %@, index => %ld",[NSThread currentThread],i);
    }
}

@end

控制台输出：

2019-09-23 11:07:57.047589+0800 NSOperationTest[2265:122701] currentThread - <NSThread: 0x60000298a280>{number = 1, name = main}, index => 0
2019-09-23 11:07:58.048536+0800 NSOperationTest[2265:122701] currentThread - <NSThread: 0x60000298a280>{number = 1, name = main}, index => 1
2019-09-23 11:07:59.049151+0800 NSOperationTest[2265:122701] currentThread - <NSThread: 0x60000298a280>{number = 1, name = main}, index => 2
2019-09-23 11:08:00.050622+0800 NSOperationTest[2265:122701] currentThread - <NSThread: 0x60000298a280>{number = 1, name = main}, index => 3

我们可以看到当前线程是主线程，相当于直接执行invocationOperationStart方法。满足我们上面所提到的在不使用 NSOperationQueue，单独使用 NSOperation 的情况下系统同步执行操作。也就是说，假如当前线程是新创建的线程，那么operation的操作也是在这个新创建的线程上同步执行的。

2.2 NSBlockOperation

_blockOperation = [NSBlockOperation blockOperationWithBlock:^{
        for (NSInteger i = 0; i < 6; i++) {
            sleep(1);
            NSLog(@"blockOperation: currentThread - %@, index => %ld",[NSThread currentThread],i);
        }
    }];
[_blockOperation start];

这样执行完成之后，跟上面NSInvocationOperation输出是一样的，都是在当前线程上同步进行操作。会阻塞当前线程。

但是，NSBlockOperation还有一个addExecutionBlock: 方法，通过 addExecutionBlock: 就可以为 NSBlockOperation 添加额外的操作。这些操作（包括 blockOperationWithBlock 中的操作）可以在不同的线程中同时（并发）执行。只有当所有相关的操作已经完成执行时，才视为完成。

如果添加的操作多的话，blockOperationWithBlock: 中的操作也可能会在其他线程（非当前线程）中执行，这是由系统决定的，并不是说添加到 blockOperationWithBlock: 中的操作一定会在当前线程中执行。（可以使用 addExecutionBlock: 多添加几个操作试试）。

@interface ViewController ()

@property (nonatomic, strong) NSBlockOperation *blockOperation;

@end

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    
    _blockOperation = [NSBlockOperation blockOperationWithBlock:^{
        for (NSInteger i = 0; i < 6; i++) {
            sleep(1);
            NSLog(@"blockOperation: currentThread - %@, index => %ld",[NSThread currentThread],i);
        }
    }];
    
    [_blockOperation addExecutionBlock:^{
        for (NSInteger i = 0; i < 6; i++) {
            sleep(1);
            NSLog(@"addExecutionBlock1: currentThread - %@, index => %ld",[NSThread currentThread],i);
        }
    }];
    
    [_blockOperation addExecutionBlock:^{
        for (NSInteger i = 0; i < 6; i++) {
            sleep(1);
            NSLog(@"addExecutionBlock2: currentThread - %@, index => %ld",[NSThread currentThread],i);
        }
    }];
    
    [_blockOperation addExecutionBlock:^{
        for (NSInteger i = 0; i < 6; i++) {
            sleep(1);
            NSLog(@"addExecutionBlock3: currentThread - %@, index => %ld",[NSThread currentThread],i);
        }
    }];
    
    [_blockOperation addExecutionBlock:^{
        for (NSInteger i = 0; i < 6; i++) {
            sleep(1);
            NSLog(@"addExecutionBlock4: currentThread - %@, index => %ld",[NSThread currentThread],i);
        }
    }];
    
    [_blockOperation addExecutionBlock:^{
        for (NSInteger i = 0; i < 6; i++) {
            sleep(1);
            NSLog(@"addExecutionBlock5: currentThread - %@, index => %ld",[NSThread currentThread],i);
        }
    }];
    
    [_blockOperation start];
    
}

@end

输出：

2019-09-23 11:14:40.593208+0800 NSOperationTest[2363:127354] addExecutionBlock4: currentThread - <NSThread: 0x6000034fdc40>{number = 1, name = main}, index => 0
2019-09-23 11:14:40.593206+0800 NSOperationTest[2363:127395] addExecutionBlock3: currentThread - <NSThread: 0x6000034ba800>{number = 3, name = (null)}, index => 0
2019-09-23 11:14:40.593209+0800 NSOperationTest[2363:127393] addExecutionBlock1: currentThread - <NSThread: 0x6000034f9340>{number = 4, name = (null)}, index => 0
2019-09-23 11:14:40.593210+0800 NSOperationTest[2363:127394] addExecutionBlock2: currentThread - <NSThread: 0x6000034f3840>{number = 7, name = (null)}, index => 0
2019-09-23 11:14:40.593206+0800 NSOperationTest[2363:127392] addExecutionBlock5: currentThread - <NSThread: 0x6000034ba240>{number = 5, name = (null)}, index => 0
2019-09-23 11:14:40.593207+0800 NSOperationTest[2363:127391] blockOperation: currentThread - <NSThread: 0x6000034f2f00>{number = 6, name = (null)}, index => 0
2019-09-23 11:14:41.593662+0800 NSOperationTest[2363:127395] addExecutionBlock3: currentThread - <NSThread: 0x6000034ba800>{number = 3, name = (null)}, index => 1
2019-09-23 11:14:41.593665+0800 NSOperationTest[2363:127394] addExecutionBlock2: currentThread - <NSThread: 0x6000034f3840>{number = 7, name = (null)}, index => 1
2019-09-23 11:14:41.593678+0800 NSOperationTest[2363:127393] addExecutionBlock1: currentThread - <NSThread: 0x6000034f9340>{number = 4, name = (null)}, index => 1
2019-09-23 11:14:41.593670+0800 NSOperationTest[2363:127392] addExecutionBlock5: currentThread - <NSThread: 0x6000034ba240>{number = 5, name = (null)}, index => 1
2019-09-23 11:14:41.593662+0800 NSOperationTest[2363:127354] addExecutionBlock4: currentThread - <NSThread: 0x6000034fdc40>{number = 1, name = main}, index => 1
2019-09-23 11:14:41.593763+0800 NSOperationTest[2363:127391] blockOperation: currentThread - <NSThread: 0x6000034f2f00>{number = 6, name = (null)}, index => 1

可以看出：使用子类 NSBlockOperation，并调用方法 AddExecutionBlock: 的情况下，blockOperationWithBlock:方法中的操作 和 addExecutionBlock: 中的操作是在不同的线程中异步执行的。

一般情况下，如果一个 NSBlockOperation 对象封装了多个操作。NSBlockOperation 是否开启新线程，取决于操作的个数。如果添加的操作的个数多，就会自动开启新线程。当然开启的线程数是由系统来决定的。

2.3 自定义Operation

如果使用子类 NSInvocationOperation、NSBlockOperation 不能满足日常需求，我们可以使用自定义继承自 NSOperation 的子类。可以通过重写 main 或者 start 方法 来定义自己的 NSOperation 对象。重写main方法比较简单，我们不需要管理操作的状态属性 isExecuting 和 isFinished。当 main 执行完返回的时候，这个操作就结束了。

重写start方法支持异步

• 修改当前的状态
• 创建下载dataTask
• 错误的处理

当operation状态为finish时：

• 清除其它任务的依赖
• 将当前的任务移除
• 执行completionBlock

我们自定义一个CustomOperation继承于NSOperation:

.h文件
@interface CustomOperation : NSOperation

@end

.m文件

@implementation CustomOperation

- (void)main{
    for (NSInteger i = 0; i < 6; i++) {
        sleep(1);
        NSLog(@"currentThread - %@, index => %ld",[NSThread currentThread],i);
    }
}

@end

controller.m文件
#import "ViewController.h"
#import "CustomOperation.h"

@interface ViewController ()

@property (nonatomic, strong) CustomOperation *customOperation;

@end

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    
    _customOperation = [[CustomOperation alloc] init];
    [_customOperation start];
}

@end

此时，运行控制台输出：

2019-09-23 11:34:36.917751+0800 NSOperationTest[2489:138343] currentThread - <NSThread: 0x600002a82140>{number = 1, name = main}, index => 0
2019-09-23 11:34:37.918310+0800 NSOperationTest[2489:138343] currentThread - <NSThread: 0x600002a82140>{number = 1, name = main}, index => 1
2019-09-23 11:34:38.918838+0800 NSOperationTest[2489:138343] currentThread - <NSThread: 0x600002a82140>{number = 1, name = main}, index => 2
2019-09-23 11:34:39.919767+0800 NSOperationTest[2489:138343] currentThread - <NSThread: 0x600002a82140>{number = 1, name = main}, index => 3
2019-09-23 11:34:40.920847+0800 NSOperationTest[2489:138343] currentThread - <NSThread: 0x600002a82140>{number = 1, name = main}, index => 4
2019-09-23 11:34:41.921831+0800 NSOperationTest[2489:138343] currentThread - <NSThread: 0x600002a82140>{number = 1, name = main}, index => 5

可以看出：在没有使用 NSOperationQueue、在主线程单独使用自定义继承自 NSOperation 的子类的情况下，是在主线程执行操作，并没有开启新线程。

3. NSOpeartionQueue

3.1 NSOperationQueue介绍

NSOperationQueue 一共有两种队列：主队列、自定义队列。其中自定义队列同时包含了串行、并发功能。下边是主队列、自定义队列的基本创建方法和特点。

• 主队列
  凡是添加到主队列中的操作，都会放到主线程中执行（注：不包括操作使用addExecutionBlock:添加的额外操作，额外操作可能在其他线程执行）。

// 主队列获取方法
NSOperationQueue *queue = [NSOperationQueue mainQueue];

• 自定义队列（非主队列）
  添加到这种队列中的操作，就会自动放到子线程中执行。
  同时包含了：串行、并发功能。

// 自定义队列创建方法
NSOperationQueue *queue = [[NSOperationQueue alloc] init];

3.2 将操作添加到队列中

上边我们说到 NSOperation 需要配合 NSOperationQueue 来实现多线程。

那么我们需要将创建好的操作加入到队列中去。总共有两种方法：

3.2.1 addOperation

#import "CustomOperation.h"

@interface ViewController ()

@property (nonatomic, strong) CustomOperation *customOperation;

@end

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    
    CustomOperation *customOperation = [[CustomOperation alloc] init];
    
    NSInvocationOperation *invocationOperation = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(invocationOperationTest) object:nil];
    
    NSBlockOperation *blockOperation = [NSBlockOperation blockOperationWithBlock:^{
        for (NSInteger i = 0; i < 6; i++) {
            sleep(1);
            NSLog(@"blockOperation: currentThread - %@, index => %ld",[NSThread currentThread],i);
        }
    }];
    
    [blockOperation addExecutionBlock:^{
        for (NSInteger i = 0; i < 6; i++) {
            sleep(1);
            NSLog(@"addExecutionBlock1: currentThread - %@, index => %ld",[NSThread currentThread],i);
        }
    }];
    
    [blockOperation addExecutionBlock:^{
        for (NSInteger i = 0; i < 6; i++) {
            sleep(1);
            NSLog(@"addExecutionBlock2: currentThread - %@, index => %ld",[NSThread currentThread],i);
        }
    }];
    
    
    NSOperationQueue *mainQueue = [[NSOperationQueue alloc] init];
    mainQueue.maxConcurrentOperationCount = 3;
    
    [mainQueue addOperation:customOperation];
    [mainQueue addOperation:blockOperation];
    [mainQueue addOperation:invocationOperation];
}

- (void)invocationOperationTest{
    for (NSInteger i = 0; i < 6; i++) {
        sleep(1);
        NSLog(@"invocationOperation: currentThread - %@, index => %ld",[NSThread currentThread],i);
    }
}

@end

控制台输出：

2019-09-23 11:57:25.657532+0800 NSOperationTest[2699:154662] addExecutionBlock1: currentThread - <NSThread: 0x600002718e80>{number = 3, name = (null)}, index => 0
2019-09-23 11:57:25.657537+0800 NSOperationTest[2699:154664] blockOperation: currentThread - <NSThread: 0x600002736a00>{number = 8, name = (null)}, index => 0
2019-09-23 11:57:25.657537+0800 NSOperationTest[2699:154661] customOperation: currentThread - <NSThread: 0x600002718c80>{number = 7, name = (null)}, index => 0
2019-09-23 11:57:25.657537+0800 NSOperationTest[2699:154665] invocationOperation: currentThread - <NSThread: 0x60000276c600>{number = 5, name = (null)}, index => 0
2019-09-23 11:57:25.657551+0800 NSOperationTest[2699:154663] addExecutionBlock2: currentThread - <NSThread: 0x600002768b00>{number = 4, name = (null)}, index => 0
2019-09-23 11:57:26.661176+0800 NSOperationTest[2699:154661] customOperation: currentThread - <NSThread: 0x600002718c80>{number = 7, name = (null)}, index => 1
2019-09-23 11:57:26.661173+0800 NSOperationTest[2699:154665] invocationOperation: currentThread - <NSThread: 0x60000276c600>{number = 5, name = (null)}, index => 1
2019-09-23 11:57:26.661173+0800 NSOperationTest[2699:154664] blockOperation: currentThread - <NSThread: 0x600002736a00>{number = 8, name = (null)}, index => 1
2019-09-23 11:57:26.661181+0800 NSOperationTest[2699:154662] addExecutionBlock1: currentThread - <NSThread: 0x600002718e80>{number = 3, name = (null)}, index => 1
2019-09-23 11:57:26.661174+0800 NSOperationTest[2699:154663] addExecutionBlock2: currentThread - <NSThread: 0x600002768b00>{number = 4, name = (null)}, index => 1
2019-09-23 11:57:27.665054+0800 NSOperationTest[2699:154661] customOperation: currentThread - <NSThread: 0x600002718c80>{number = 7, name = (null)}, index => 2
2019-09-23 11:57:27.665054+0800 NSOperationTest[2699:154665] invocationOperation: currentThread - <NSThread: 0x60000276c600>{number = 5, name = (null)}, index => 2
2019-09-23 11:57:27.665054+0800 NSOperationTest[2699:154662] addExecutionBlock1: currentThread - <NSThread: 0x600002718e80>{number = 3, name = (null)}, index => 2
2019-09-23 11:57:27.665054+0800 NSOperationTest[2699:154663] addExecutionBlock2: currentThread - <NSThread: 0x600002768b00>{number = 4, name = (null)}, index => 2
2019-09-23 11:57:27.665078+0800 NSOperationTest[2699:154664] blockOperation: currentThread - <NSThread: 0x600002736a00>{number = 8, name = (null)}, index => 2
2019-09-23 11:57:28.669199+0800 NSOperationTest[2699:154665] invocationOperation: currentThread - <NSThread: 0x60000276c600>{number = 5, name = (null)}, index => 3
2019-09-23 11:57:28.669201+0800 NSOperationTest[2699:154661] customOperation: currentThread - <NSThread: 0x600002718c80>{number = 7, name = (null)}, index => 3
...

可以看出使用 NSOperation 子类创建操作，并使用 addOperation: 将操作加入到操作队列后能够开启新线程，进行并发执行。

3.2.2 addOperationWithBlock

无需先创建操作，在 block 中添加操作，直接将包含操作的 block 加入到队列中。

@interface ViewController ()

@end

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];;
    queue.maxConcurrentOperationCount = 3;
    
    [queue addOperationWithBlock:^{
        for (NSInteger i = 0; i < 6; i++) {
            sleep(1);
            NSLog(@"OperationWithBlock1: currentThread - %@, index => %ld",[NSThread currentThread],i);
        }
    }];
    
    [queue addOperationWithBlock:^{
        for (NSInteger i = 0; i < 6; i++) {
            sleep(1);
            NSLog(@"OperationWithBlock2: currentThread - %@, index => %ld",[NSThread currentThread],i);
        }
    }];
    
    [queue addOperationWithBlock:^{
        for (NSInteger i = 0; i < 6; i++) {
            sleep(1);
            NSLog(@"OperationWithBlock3: currentThread - %@, index => %ld",[NSThread currentThread],i);
        }
    }];
}

@end

输出结果:

2019-09-23 13:36:53.715723+0800 NSOperationTest[2855:184521] OperationWithBlock2: currentThread - <NSThread: 0x60000261ad80>{number = 5, name = (null)}, index => 0
2019-09-23 13:36:53.715723+0800 NSOperationTest[2855:184524] OperationWithBlock3: currentThread - <NSThread: 0x60000265ea40>{number = 3, name = (null)}, index => 0
2019-09-23 13:36:53.715723+0800 NSOperationTest[2855:184523] OperationWithBlock1: currentThread - <NSThread: 0x6000026d2cc0>{number = 7, name = (null)}, index => 0
2019-09-23 13:36:54.720633+0800 NSOperationTest[2855:184524] OperationWithBlock3: currentThread - <NSThread: 0x60000265ea40>{number = 3, name = (null)}, index => 1
2019-09-23 13:36:54.720633+0800 NSOperationTest[2855:184523] OperationWithBlock1: currentThread - <NSThread: 0x6000026d2cc0>{number = 7, name = (null)}, index => 1
2019-09-23 13:36:54.720641+0800 NSOperationTest[2855:184521] OperationWithBlock2: currentThread - <NSThread: 0x60000261ad80>{number = 5, name = (null)}, index => 1
2019-09-23 13:36:55.725485+0800 NSOperationTest[2855:184524] OperationWithBlock3: currentThread - <NSThread: 0x60000265ea40>{number = 3, name = (null)}, index => 2
2019-09-23 13:36:55.725516+0800 NSOperationTest[2855:184523] OperationWithBlock1: currentThread - <NSThread: 0x6000026d2cc0>{number = 7, name = (null)}, index => 2
2019-09-23 13:36:55.725511+0800 NSOperationTest[2855:184521] OperationWithBlock2: currentThread - <NSThread: 0x60000261ad80>{number = 5, name = (null)}, index => 2
2019-09-23 13:36:56.730603+0800 NSOperationTest[2855:184521] OperationWithBlock2: currentThread - <NSThread: 0x60000261ad80>{number = 5, name = (null)}, index => 3
2019-09-23 13:36:56.730603+0800 NSOperationTest[2855:184524] OperationWithBlock3: currentThread - <NSThread: 0x60000265ea40>{number = 3, name = (null)}, index => 3
2019-09-23 13:36:56.730628+0800 NSOperationTest[2855:184523] OperationWithBlock1: currentThread - <NSThread: 0x6000026d2cc0>{number = 7, name = (null)}, index => 3
2019-09-23 13:36:57.733808+0800 NSOperationTest[2855:184521] OperationWithBlock2: currentThread - <NSThread: 0x60000261ad80>{number = 5, name = (null)}, index => 4
2019-09-23 13:36:57.733808+0800 NSOperationTest[2855:184524] OperationWithBlock3: currentThread - <NSThread: 0x60000265ea40>{number = 3, name = (null)}, index => 4
2019-09-23 13:36:57.733808+0800 NSOperationTest[2855:184523] OperationWithBlock1: currentThread - <NSThread: 0x6000026d2cc0>{number = 7, name = (null)}, index => 4
2019-09-23 13:36:58.736158+0800 NSOperationTest[2855:184521] OperationWithBlock2: currentThread - <NSThread: 0x60000261ad80>{number = 5, name = (null)}, index => 5
2019-09-23 13:36:58.736162+0800 NSOperationTest[2855:184524] OperationWithBlock3: currentThread - <NSThread: 0x60000265ea40>{number = 3, name = (null)}, index => 5
2019-09-23 13:36:58.736173+0800 NSOperationTest[2855:184523] OperationWithBlock1: currentThread - <NSThread: 0x6000026d2cc0>{number = 7, name = (null)}, index => 5

同样会创建新线程，异步并发执行。

3.3 NSOperationQueue 控制串行执行、并发执行

之前我们说过，NSOperationQueue 创建的自定义队列同时具有串行、并发功能，上边我们演示了并发功能，那么他的串行功能是如何实现的？

这里有个关键属性 maxConcurrentOperationCount，叫做最大并发操作数。用来控制一个特定队列中可以有多少个操作同时参与并发执行。

注意：这里 maxConcurrentOperationCount 控制的不是并发线程的数量，而是一个队列中同时能并发执行的最大操作数。而且一个操作也并非只能在一个线程中运行。

最大并发操作数：maxConcurrentOperationCount

• maxConcurrentOperationCount 默认情况下为-1，表示不进行限制，可进行并发执行。
• maxConcurrentOperationCount 为1时，队列为串行队列。只能串行执行。
• maxConcurrentOperationCount 大于1时，队列为并发队列。操作并发执行，当然这个值不应超过系统限制，即使自己设置一个很大的值，系统也会自动调整为 min{自己设定的值，系统设定的默认最大值}。

这里可以自己写个demo验证一下，使用自定义队列，添加多个任务，设置maxConcurrentOperationCount = 1 时，是串行执行，设置maxConcurrentOperationCount > 1是并发执行。

3.4 NSOperation 操作依赖

NSOperation、NSOperationQueue 最吸引人的地方是它能添加操作之间的依赖关系。通过操作依赖，我们可以很方便的控制操作之间的执行先后顺序。NSOperation 提供了3个接口供我们管理和查看依赖。

- (void)addDependency:(NSOperation *)op; 添加依赖，使当前操作依赖于操作 op 的完成。
- (void)removeDependency:(NSOperation *)op; 移除依赖，取消当前操作对操作 op 的依赖。
@property (readonly, copy) NSArray<NSOperation *> *dependencies; 在当前操作开始执行之前完成执行的所有操作对象数组。

NSOperation支持的依赖项并不区分依赖项操作是否成功完成。(换句话说，取消一个操作类似地将其标记为已完成)。在依赖operation被cancenl或没有成功完成任务的情况下，再决定是否应该继续执行具有依赖项的操作。这可能需要将额外的错误跟踪功能合并到operation中。

注意：上面有提到，当一个任务B所依赖的任务A还没有执行完成的时候，任务B是处于非ready状态的，只有当A执行完成了（B所依赖的任务全部完成了），任务B才会变成ready状态。

当然，我们经常用到的还是添加依赖操作。现在考虑这样的需求，比如说有 A、B 两个操作，其中 A 执行完操作，B 才能执行操作。

如果使用依赖来处理的话，那么就需要让操作 B 依赖于操作 A。具体代码如下：

@interface ViewController ()

@end

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    
    
    NSBlockOperation *blockOperationA = [NSBlockOperation blockOperationWithBlock:^{
        for (NSInteger i = 0; i < 5; i++) {
            sleep(1);
            NSLog(@"blockOperationA: currentThread - %@, index => %ld",[NSThread currentThread],i);
        }
    }];
    
    NSBlockOperation *blockOperationB = [NSBlockOperation blockOperationWithBlock:^{
        for (NSInteger i = 0; i < 5; i++) {
            sleep(1);
            NSLog(@"blockOperationB: currentThread - %@, index => %ld",[NSThread currentThread],i);
        }
    }];
    
    NSBlockOperation *blockOperationC = [NSBlockOperation blockOperationWithBlock:^{
        for (NSInteger i = 0; i < 5; i++) {
            sleep(1);
            NSLog(@"blockOperationC: currentThread - %@, index => %ld",[NSThread currentThread],i);
        }
    }];
    
    [blockOperationB addDependency:blockOperationA];
    
    blockOperationA.completionBlock = ^{
        if (blockOperationB.isReady) {
            NSLog(@"任务A执行完成之后operationB准备好了");
        }else{
            NSLog(@"任务A执行完成之后operationB没有准备好");
        }
    };
    
    if (blockOperationB.isReady) {
        NSLog(@"添加到队列之前operationB准备好了");
    }else{
        NSLog(@"添加到队列之前operationB没有准备好");
    }
    
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];
    [queue addOperation:blockOperationA];
    [queue addOperation:blockOperationB];
    [queue addOperation:blockOperationC];
}
@end

控制台输出：

2019-09-23 13:49:56.608968+0800 NSOperationTest[3052:193320] 添加到队列之前operationB没有准备好
2019-09-23 13:49:57.614244+0800 NSOperationTest[3052:193476] blockOperationA: currentThread - <NSThread: 0x600003e6acc0>{number = 3, name = (null)}, index => 0
2019-09-23 13:49:57.614239+0800 NSOperationTest[3052:193472] blockOperationC: currentThread - <NSThread: 0x600003e6ca00>{number = 6, name = (null)}, index => 0
2019-09-23 13:49:58.619598+0800 NSOperationTest[3052:193476] blockOperationA: currentThread - <NSThread: 0x600003e6acc0>{number = 3, name = (null)}, index => 1
2019-09-23 13:49:58.619657+0800 NSOperationTest[3052:193472] blockOperationC: currentThread - <NSThread: 0x600003e6ca00>{number = 6, name = (null)}, index => 1
2019-09-23 13:49:59.623347+0800 NSOperationTest[3052:193472] blockOperationC: currentThread - <NSThread: 0x600003e6ca00>{number = 6, name = (null)}, index => 2
2019-09-23 13:49:59.623347+0800 NSOperationTest[3052:193476] blockOperationA: currentThread - <NSThread: 0x600003e6acc0>{number = 3, name = (null)}, index => 2
2019-09-23 13:50:00.628615+0800 NSOperationTest[3052:193476] blockOperationA: currentThread - <NSThread: 0x600003e6acc0>{number = 3, name = (null)}, index => 3
2019-09-23 13:50:00.628617+0800 NSOperationTest[3052:193472] blockOperationC: currentThread - <NSThread: 0x600003e6ca00>{number = 6, name = (null)}, index => 3
2019-09-23 13:50:01.632175+0800 NSOperationTest[3052:193476] blockOperationA: currentThread - <NSThread: 0x600003e6acc0>{number = 3, name = (null)}, index => 4
2019-09-23 13:50:01.632175+0800 NSOperationTest[3052:193472] blockOperationC: currentThread - <NSThread: 0x600003e6ca00>{number = 6, name = (null)}, index => 4
2019-09-23 13:50:01.632483+0800 NSOperationTest[3052:193476] 任务A执行完成之后operationB准备好了
2019-09-23 13:50:02.636373+0800 NSOperationTest[3052:193472] blockOperationB: currentThread - <NSThread: 0x600003e6ca00>{number = 6, name = (null)}, index => 0
2019-09-23 13:50:03.638088+0800 NSOperationTest[3052:193472] blockOperationB: currentThread - <NSThread: 0x600003e6ca00>{number = 6, name = (null)}, index => 1
2019-09-23 13:50:04.639857+0800 NSOperationTest[3052:193472] blockOperationB: currentThread - <NSThread: 0x600003e6ca00>{number = 6, name = (null)}, index => 2
2019-09-23 13:50:05.643648+0800 NSOperationTest[3052:193472] blockOperationB: currentThread - <NSThread: 0x600003e6ca00>{number = 6, name = (null)}, index => 3
2019-09-23 13:50:06.647131+0800 NSOperationTest[3052:193472] blockOperationB: currentThread - <NSThread: 0x600003e6ca00>{number = 6, name = (null)}, index => 4

我们可以看到，

• operationB一直到operationA执行完成后才会变成准备好的状态。
• operationA和operationC是并发执行，operationB等到其所依赖的任务A完成后，才去执行的。

3.5 NSOperation 操作优先级

NSOperation 提供了queuePriority（优先级）属性，queuePriority属性适用于同一操作队列中的操作，不适用于不同操作队列中的操作。默认情况下，所有新创建的操作对象优先级都是NSOperationQueuePriorityNormal。但是我们可以通过setQueuePriority:方法来改变当前操作在同一队列中的执行优先级。

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

上边我们说过：对于添加到队列中的操作，首先进入准备就绪的状态（就绪状态取决于操作之间的依赖关系），然后进入就绪状态的操作的开始执行顺序（非结束执行顺序）由操作之间相对的优先级决定（优先级是操作对象自身的属性）。

那么，什么样的操作才是进入就绪状态的操作呢？

• 当一个操作的所有依赖都已经完成时，操作对象通常会进入准备就绪状态，等待执行。
  举个例子，现在有4个优先级都是 NSOperationQueuePriorityNormal（默认级别）的操作：op1，op2，op3，op4。其中 op3 依赖于 op2，op2 依赖于 op1，即 op3 -> op2 -> op1。现在将这4个操作添加到队列中并发执行。
  因为 op1 和 op4 都没有需要依赖的操作，所以在 op1，op4 执行之前，就是处于准备就绪状态的操作。
  而 op3 和 op2 都有依赖的操作（op3 依赖于 op2，op2 依赖于 op1），所以 op3 和 op2 都不是准备就绪状态下的操作。

• 可以使用addDependency:和removeDependency:方法为操作添加和删除依赖项。默认情况下，具有依赖项的operation在所有依赖的operation都执行完之前不会被认为已经准备好。然而，一旦最后一个依赖operation完成，操作对象就准备好并能够执行了(ready)。

理解了进入就绪状态的操作，那么我们就理解了queuePriority 属性的作用对象。

• queuePriority 属性决定了进入准备就绪状态下的操作之间的开始执行顺序。并且，优先级不能取代依赖关系。并且优先级并不能完全决定开始执行顺序。
• 如果一个队列中既包含高优先级操作，又包含低优先级操作，并且两个操作都已经准备就绪，那么队列先执行高优先级操作。比如上例中，如果 op1 和 op4 是不同优先级的操作，那么就会先执行优先级高的操作。
  如果，一个队列中既包含了准备就绪状态的操作，又包含了未准备就绪的操作，未准备就绪的操作优先级比准备就绪的操作优先级高。那么，虽然准备就绪的操作优先级低，也会优先执行。优先级不能取代依赖关系。如果要控制操作间的启动顺序，则必须使用依赖关系。

3.6 NSOperation、NSOperationQueue 线程间的通信

在 iOS 开发过程中，我们一般在主线程里边进行 UI 刷新，例如：点击、滚动、拖拽等事件。我们通常把一些耗时的操作放在其他线程，比如说图片下载、文件上传等耗时操作。而当我们有时候在其他线程完成了耗时操作时，需要回到主线程，那么就用到了线程之间的通讯。

/**
 * 线程间通信
 */
- (void)communication {

    // 1.创建队列
    NSOperationQueue *queue = [[NSOperationQueue alloc]init];

    // 2.添加操作
    [queue addOperationWithBlock:^{
        // 异步进行耗时操作
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
            NSLog(@"1---%@", [NSThread currentThread]); // 打印当前线程
        }

        // 回到主线程
        [[NSOperationQueue mainQueue] addOperationWithBlock:^{
            // 进行一些 UI 刷新等操作
            for (int i = 0; i < 2; i++) {
                [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
                NSLog(@"2---%@", [NSThread currentThread]); // 打印当前线程
            }
        }];
    }];
}

通过线程间的通信，先在其他线程中执行操作，等操作执行完了之后再回到主线程执行主线程的相应操作。

3.7 NSOperationQueue 常用属性和方法

取消/暂停/恢复操作
- (void)cancelAllOperations; 可以取消队列的所有操作。
- (BOOL)isSuspended; 判断队列是否处于暂停状态。 YES 为暂停状态，NO 为恢复状态。
- (void)setSuspended:(BOOL)b; 可设置操作的暂停和恢复，YES 代表暂停队列，NO 代表恢复队列。
操作同步
- (void)waitUntilAllOperationsAreFinished; 阻塞当前线程，直到队列中的操作全部执行完毕。
添加/获取操作`
- (void)addOperationWithBlock:(void (^)(void))block; 向队列中添加一个 NSBlockOperation 类型操作对象。
- (void)addOperations:(NSArray *)ops waitUntilFinished:(BOOL)wait; 向队列中添加操作数组，wait 标志是否阻塞当前线程直到所有操作结束
- (NSArray *)operations; 当前在队列中的操作数组（某个操作执行结束后会自动从这个数组清除）。
- (NSUInteger)operationCount; 当前队列中的操作数。
获取队列
+ (id)currentQueue; 获取当前队列，如果当前线程不是在 NSOperationQueue 上运行则返回 nil。
+ (id)mainQueue; 获取主队列。

注意：cancel操作不会立即停止正在执行的操作。尽管所有操作都需要考虑cancel属性中的值，但代码中必须显式地检查cancel属性中的值，并根据需要中止。
NSOperation的开始执行之前会会有取消状态检查。例如，如果在调用某个操作的start方法之前调用cancel方法，则start方法将不启动该任务而退出。