NSOperation、NSOperationQueue 是基于 GCD 更高一层的封装，完全面向对象。但是比 GCD 更简单易用、代码可读性也更高。
1.为什么要使用 NSOperation、NSOperationQueue？
- 可添加完成的代码块，在操作完成后执行。
- 添加操作之间的依赖关系，方便的控制执行顺序。
- 设定操作执行的优先级。
- 可以设置最大并发数。
- 可以很方便的取消一个操作的执行。
- 使用 KVO 观察对操作执行状态的更改：
isExecuteing、isFinished、isCancelled
2.常用类
既然是基于 GCD 的更高一层的封装。那么，GCD 中的一些概念同样适用于 NSOperation、NSOperationQueue。在 NSOperation、NSOperationQueue 中也有类似的任务（操作）和队列（操作队列）的概念。
-
操作（Operation）：
- 执行操作的意思，换句话说就是你在线程中执行的那段代码。
- 在 GCD 中是放在 block 中的。在 NSOperation 中，我们使用 NSOperation 子类 NSInvocationOperation、NSBlockOperation，或者自定义子类来封装操作。
-
操作队列（Operation Queues）：
- 这里的队列指操作队列，即用来存放操作的队列。不同于 GCD 中的调度队列 FIFO（先进先出）的原则。NSOperationQueue 对于添加到队列中的操作，首先进入准备就绪的状态（就绪状态取决于操作之间的依赖关系），然后进入就绪状态的操作的开始执行顺序（非结束执行顺序）由操作之间相对的优先级决定（优先级是操作对象自身的属性）。
- 操作队列通过设置最大并发操作数（maxConcurrentOperationCount）来控制并发、串行。
- NSOperationQueue 为我们提供了两种不同类型的队列：主队列和自定义队列。主队列运行在主线程之上，而自定义队列在后台执行。
3.NSOperation的使用
NSOperation 是个抽象类，不能用来封装操作。我们只有使用它的子类来封装操作。我们有三种方式来封装操作。
⚠️在不使用 NSOperationQueue，单独使用 NSOperation 的情况下，是 同步操作
⚠️如果自定义继承自 NSOperation 的子类，重写start方法在子线程中进行，可以实现异步操作
1). 使用子类 NSInvocationOperation
// 1.创建 NSInvocationOperation 对象
NSInvocationOperation *op = [[NSInvocationOperation alloc] initWithTarget: self
selector: @selector(task1)
object: nil];
// 2.调用 start 方法开始执行操作
[op start];
在没有使用 NSOperationQueue、在主线程中单独使用使用子类 NSInvocationOperation 执行一个操作的情况下，操作是在当前线程执行的，并没有开启新线程。
2). 使用子类 NSBlockOperation
// 1.创建 NSBlockOperation 对象
NSBlockOperation *op = [NSBlockOperation blockOperationWithBlock:^{
NSLog(@"1---%@", [NSThread currentThread]); // 打印当前线程
}];
// 2.调用 start 方法开始执行操作
[op start];
在没有使用 NSOperationQueue、在主线程中单独使用 NSBlockOperation 执行一个操作的情况下，操作是在当前线程执行的，并没有开启新线程。
NSBlockOperation还可以添加额外的操作：
[op addExecutionBlock:^{
}];
[op addExecutionBlock:^{
}];
[op start];
使用子类 NSBlockOperation，并调用方法 AddExecutionBlock:的情况下，blockOperationWithBlock:方法中的操作 和addExecutionBlock:中的操作有可能均在新开启的线程中进行。
NSBlockOperation 是否开启新线程，取决于操作的个数。如果添加的操作的个数多，就会自动开启新线程。当然开启的线程数是由系统来决定的。
3). 自定义继承自 NSOperation 的子类，通过实现内部相应的方法来封装操作。
我们可以自定义非并发和并发两种不同类型的 NSOperation 子类。
从最低限度上来说，每一个 operation 都应该至少实现以下两个方法：
- 一个自定义的初始化方法，将创建的 operation 置于一个已知的状态
- 重写 main 方法来执行我们的任务
例如:
- (id)initWithData:(id)data {
if ([super init]) {
}
return self;
}
- (void)main {
}
自定义NSOperation支持取消
当一个 operation 开始执行后，它会一直执行它的任务直到完成或被取消为止。我们可以在任意时间点取消一个 operation ，甚至是在它还未开始执行之前。
为了让我们自定义的 operation 能够支持取消事件，我们需要在代码中定期地检查isCancelled方法的返回值，一旦检查到这个方法返回 YES ，我们就需要立即停止执行接下来的任务。
通常来说，当我们自定义一个 operation 类时，我们需要考虑在以下几个关键点检查 isCancelled 方法的返回值：
- 在真正开始执行任务之前；
- 至少在每次循环中检查一次，而如果一次循环的时间本身就比较长的话，则需要检查得更加频繁；
- 在任何相对来说比较容易中止 operation 的地方。
看到这里，我想你应该可以意识到一点，那就是尽管 operation 是支持取消操作的，但却并不是立即取消的，而是在你调用了 operation 的 cancel 方法之后的下一个 isCancelled 的检查点取消的。
- (void)main {
if (self.isCancelled) return;
for (NSUInteger i = 0; i < 3; i++) {
if (self.isCancelled) return;
NSLog(@"Loop %@", @(i + 1));
}
}
配置并发的自定义NSOperation
在 operation 和 operation queue 结合使用时，operation queue 可以为非并发的 operation 提供线程，但是，如果你想要手动地执行一个 operation ，又想这个 operation 能够异步执行的话，你需要做一些额外的配置来让你的 operation 支持并发执行。
下面列举了一些你可能需要重写的方法：
-
start：必须的。
所有并发执行的 operation 都必须要重写这个方法，替换掉 NSOperation 类中的默认实现。start 方法是一个 operation 的起点，我们可以在这里配置任务执行的线程或者一些其它的执行环境。
另外，需要特别注意的是，在我们重写的 start 方法中一定不要调用父类的实现； -
main：可选的。
通常这个方法就是专门用来实现与该 operation 相关联的任务的。尽管我们可以直接在 start 方法中执行我们的任务，但是用 main 方法来实现我们的任务可以使设置代码和任务代码得到分离，从而使 operation 的结构更清晰； -
isExecuting和isFinished：必须的。
并发执行的 operation 需要负责配置它们的执行环境，并且向外界客户报告执行环境的状态。因此，一个并发执行的 operation 必须要维护一些状态信息，用来记录它的任务是否正在执行，是否已经完成执行等。
此外，当这两个方法所代表的值发生变化时，我们需要生成相应的 KVO 通知，以便外界能够观察到这些状态的变化； -
isConcurrent：必须的。
这个方法的返回值用来标识一个 operation 是否是并发的 operation ，我们需要重写这个方法并返回 YES 。
例如：
@synthesize executing = _executing;
@synthesize finished = _finished;
- (id)init {
self = [super init];
if (self) {
_executing = NO;
_finished = NO;
}
return self;
}
- (BOOL)isConcurrent {
return YES;
}
- (BOOL)isExecuting {
return _executing;
}
- (BOOL)isFinished {
return _finished;
}
- (void)start {
if (self.isCancelled) {
[self willChangeValueForKey:@"isFinished"];
_finished = YES;
[self didChangeValueForKey:@"isFinished"];
return;
}
[self willChangeValueForKey:@"isExecuting"];
[NSThread detachNewThreadSelector:@selector(main) toTarget:self withObject:nil];
_executing = YES;
[self didChangeValueForKey:@"isExecuting"];
}
// 任务真正开始执行
- (void)main {
@try {
NSLog(@"Start executing %@, mainThread: %@, currentThread: %@", NSStringFromSelector(_cmd), [NSThread mainThread], [NSThread currentThread]);
[self willChangeValueForKey:@"isExecuting"];
_executing = NO;
[self didChangeValueForKey:@"isExecuting"];
[self willChangeValueForKey:@"isFinished"];
_finished = YES;
[self didChangeValueForKey:@"isFinished"];
NSLog(@"Finish executing %@", NSStringFromSelector(_cmd));
}
@catch (NSException *exception) {
NSLog(@"Exception: %@", exception);
}
}
注意：
- 与重写 main 方法不同的是，如果我们重写了 start 方法或者对 NSOperation 类做了大量定制的话，我们需要保证自定义的 operation 在这些 key paths 上仍然支持 KVO 通知。比如，当我们重写了 start 方法时，我们需要特别关注的是 isExecuting 和 isFinished 这两个 key paths ，因为这两个 key paths 最可能受重写 start 方法的影响。
- 即使一个 operation 是被 cancel 掉了，我们仍然需要手动触发 isFinished 的 KVO 通知。
因为当一个 operation 依赖其他 operation 时，它会观察所有其他 operation 的 isFinished 的值的变化，只有当它依赖的所有 operation 的 isFinished 的值为 YES 时，这个 operation 才能够开始执行。
因此，如果一个我们自定义的 operation 被取消了但却没有手动触发 isFinished 的 KVO 通知的话，那么所有依赖它的 operation 都不会执行。
NSOperation 类的以下 key paths 支持 KVO 通知，我们可以通过观察这些 key paths 非常方便地监听到一个 operation 内部状态的变化：
- isCancelled
- isConcurrent
- isExecuting
- isFinished
- isReady
- dependencies
- queuePriority
- completionBlock
附：
虽然我们可以同时使用NSOperation和NSOperationQueue来创建并发任务，
但是我们也可以单独使用NSOperation实现：
创建NSOperation子类，并且在start方法中判断当前Operation是否是并发操作
- (void)start {
if (operation.isCancelled) {
ranIt = YES;
} else if (operation.isReady) {
if (!operation.isConcurrent) {
[operation start];
} else {
[NSThread detachNewThreadSelector:@selector(start) toTarget:operation withObject:nil];
}
ranIt = YES;
}
}
4).设置CompletionBlock
一个 operation 可以在它的主任务执行完成时回调一个 completion block 。我们可以用 completion block 来执行一些主任务之外的工作，比如，我们可以用它来通知一些客户 operation 已经执行完毕，而并发的 operation 也可以用这个 block 来生成最终的 KVO 通知。如果需要设置一个 operation 的 completion block ，直接调用 NSOperation 类的 setCompletionBlock: 方法即可。
注意，当一个 operation 被取消时，它的 completion block 仍然会执行，所以我们需要在真正执行代码前检查一下 isCancelled 方法的返回值。另外，我们也没有办法保证 completion block 被回调时一定是在主线程，理论上它应该是与触发 isFinished 的 KVO 通知所在的线程一致的，所以如果有必要的话我们可以在 completion block 中使用 GCD 来保证从主线程更新 UI 。
5).取消、暂停
一旦一个 operation 被添加到 operation queue 后，唯一从 operation queue 中出队一个 operation 的方式就是调用它的 cancel 方法取消这个 operation ，或者直接调用 operation queue 的 cancelAllOperations 方法取消这个 operation queue 中所有的 operation 。
另外，我们前面也提到了，当一个 operation 被取消后，这个 operation 的 isFinished 状态也会变成 YES ，这样处理的好处就是所有依赖它的 operation 能够接收到这个 KVO 通知，从而能够清除这个依赖关系正常执行。
如果我们想要暂停和恢复执行 operation queue 中的 operation ，可以通过调用 operation queue 的 setSuspended:方法来实现这个目的。不过需要注意的是，暂停执行 operation queue 并不能使正在执行的 operation 暂停执行，而只是简单地暂停调度新的 operation 。另外，我们并不能单独地暂停执行一个 operation ，除非直接 cancel 掉。
4.NSOperationQueue和NSOperation配合使用
1). 设置最大并发数
NSOperationQueue的属性 maxConcurrentOperationCount最大并发操作数,用来控制一个特定队列中可以有多少个操作同时参与并发执行。
-
maxConcurrentOperationCount默认情况下为-1，表示不进行限制，可进行并发执行。 -
maxConcurrentOperationCount为1时，队列为串行队列。只能串行执行。 -
maxConcurrentOperationCount大于1时，队列为并发队列。操作并发执行，当然这个值不应超过系统限制，即使自己设置一个很大的值，系统也会自动调整为 min{自己设定的值，系统设定的默认最大值}。
// 创建队列
NSOperationQueue *queue = [[NSOperationQueue alloc] init];
queue.maxConcurrentOperationCount = 1; // 串行队列
// queue.maxConcurrentOperationCount = 2; // 并发队列
// queue.maxConcurrentOperationCount = -1; // 默认值， 并发队列
[queue addOperationWithBlock:^{
}];
[queue addOperationWithBlock:^{
}];
2).设置操作依赖
// 1.创建队列
NSOperationQueue *queue = [[NSOperationQueue alloc] init];
// 2.创建操作
NSBlockOperation *op1 = [NSBlockOperation blockOperationWithBlock:^{
}];
NSBlockOperation *op2 = [NSBlockOperation blockOperationWithBlock:^{
}];
// 3.添加依赖
[op2 addDependency:op1]; // 让op2 依赖于 op1，则先执行op1，在执行op2
// 4.添加操作到队列中
[queue addOperation:op1];
[queue addOperation:op2];
3).设置优先级
NSOperation 提供了queuePriority（优先级）属性，queuePriority属性适用于 同一操作队列 中的操作，不适用于不同操作队列中的操作。
当一个操作的所有依赖都已经完成时，即isReady为YES，操作对象通常会进入准备就绪状态，等待执行。
queuePriority属性决定了进入准备就绪状态下的操作之间的开始执行顺序。并且，优先级不能取代依赖关系。
如果一个队列中既包含高优先级操作，又包含低优先级操作，并且两个操作都已经准备就绪，那么队列先执行高优先级操作。
如果，一个队列中既包含了准备就绪状态的操作，又包含了未准备就绪的操作，未准备就绪的操作优先级比准备就绪的操作优先级高。那么，虽然准备就绪的操作优先级低，也会优先执行。优先级不能取代依赖关系。如果要控制操作间的启动顺序，则必须使用依赖关系。
5.线程间通信
// 1.创建队列
NSOperationQueue *queue = [[NSOperationQueue alloc]init];
// 2.添加操作
[queue addOperationWithBlock:^{
// 异步进行耗时操作
// 回到主线程
[[NSOperationQueue mainQueue] addOperationWithBlock:^{
// 进行一些 UI 刷新等操作
}];
}];