简介
NSOperation，NSOperationQueue 是苹果提供给我们的一套多线程解决方案。实际上 NSOPeration，NSOperationQueue是基于 GCD 更高一层的封装，完全面向对象。但是比 GCD 更简单易用，代码可读性更高。
优势
- 可添加完成的代码块，在操作完成后执行。
- 添加操作之间的依赖关系，方便的控制执行顺序。
- 设定操作执行的优先级。
- 可以很方便的取消一个操作的执行。
- 使用
KVO观察对操作执行状态的更改：isExecuteing，isFinished，isCancelled。
操作和操作队列
- 操作
Operation：- 执行操作的意思，即在线程中执行的那段代码。
- 在
GCD中是放在block中的。在NSOperation中，我们使用NSOperation子类NSInvocationOperation，NSBlockOperation，或者时自定义子类来封装操作。
- 操作队列
Operation Queue：- 这里的队列指操作队列，即用来存放操作的队列。不同于
GCD中的调度队列FIFO（先进先出）的原则。NSOperationQueue对于添加到队列中的操作，首先进入准备就绪的状态（就绪状态取决于操作之间的依赖关系），然后进入就绪状态的操作的开始执行顺序（非结束执行顺序），由操作之间相对的优先级决定（优先级是操作对象自身的属性）。 - 操作队列通过设置最大并发操作数
maxConcurrentOperationCount来控制并发，串行。 -
NSOperationQueue为我们提供了两种不同类型的队列：主队列和自定义队列。主队列运行在主线程之上，而自定义队列在后台执行。
- 这里的队列指操作队列，即用来存放操作的队列。不同于
使用步骤
NSOperation 需要配合 NSOperationQueue 来实现多线程。因为默认情况下，NSOperation 单独使用时系统同步执行操作，配合 NSOperationQueue，我们能更好的实现异步执行。
1. 创建操作：
NSOperation 是个抽象类，不能用来封装操作。我们只有使用它的子类来封装操作。我们可以使用三种方式来封装操作，NSInvocationOperation、NSBlockOperation、自定义继承自 NSOperation 的子类。
-
NSInvocationOperation：
/** 使用子类 NSInvocationOperation */ - (void)useInvocationOperation { // 1.创建NSInvocationOperation对象 NSInvocationOperation *op = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(task1) object:nil]; // 2.开始执行操作 [op start]; } - (void)task1 { for (int i = 0; i < 2; i++) { [NSThread sleepForTimeInterval:2]; // 模拟耗时操作 NSLog(@"%d---%@",i, [NSThread currentThread]); // 打印当前线程 } }输出结果为：
2020-03-18 10:48:31.519774+0800 多线程[13062:808176] 0---<NSThread: 0x600002fca0c0>{number = 1, name = main} 2020-03-18 10:48:33.520189+0800 多线程[13062:808176] 1---<NSThread: 0x600002fca0c0>{number = 1, name = main}可以看到，在没有使用
NSOperationQueue，在主线程中单独使用子类NSInvocationOperation执行一个操作的情况下，操作是在当前线程执行的，并没有开启新线程。 -
NSBlockOperation：
- (void)useBlockOperation { // 创建 NSBlockOperation 对象 NSBlockOperation *op = [NSBlockOperation blockOperationWithBlock:^{ for (int i = 0; i < 2; i++) { [NSThread sleepForTimeInterval:2]; // 模拟耗时操作 NSLog(@"%d---%@",i, [NSThread currentThread]); // 打印当前线程 } }]; // 开始执行操作 [op start]; }输出结果为：
2020-03-18 10:56:33.238153+0800 多线程[13156:816161] 0---<NSThread: 0x6000023ee0c0>{number = 1, name = main} 2020-03-18 10:56:35.239531+0800 多线程[13156:816161] 1---<NSThread: 0x6000023ee0c0>{number = 1, name = main}可以看到：在没有使用
NSOperationQueue，在主线程单独使用NSBlockOperation执行一个操作的情况下，操作是在当前线程执行的，并没有开启新线程。NSBlockOperation还提供了一个方法
addExecutionBlock:，通过addExecutionBlock就可以为NSBlockOperation添加额外的操作。这些操作（包括blockOperationWithBlock中的操作）可以再不同的线程中同时（并发）执行。只有当所有相关的操作已经执行完成时，才视为完成。如果添加的操作多的话，
blockOperationWithBlock:中的操作也可能会在其他线程（非当前线程）中执行，这是由系统决定的，并不是说添加到blockOperationWithBlock:中的操作一定会在当前线程中执行。（可以使用addExecutionBlock:多添加几个操作试试）。/** 使用子类 NSBlockOperation调用AddExecutionBlock方法 */ - (void)useBlockOperationAddExecutionBlock { // 创建 NSBlockOperation 对象 NSBlockOperation *op = [NSBlockOperation blockOperationWithBlock:^{ for (int i = 0; i < 2; i++) { [NSThread sleepForTimeInterval:2]; // 模拟耗时操作 NSLog(@"1---%d---%@",i, [NSThread currentThread]); // 打印当前线程 } }]; // 添加额外的操作 [op addExecutionBlock:^{ for (int i = 0; i < 2; i++) { [NSThread sleepForTimeInterval:2]; // 模拟耗时操作 NSLog(@"2---%d---%@",i, [NSThread currentThread]); // 打印当前线程 } }]; // 添加额外的操作 [op addExecutionBlock:^{ for (int i = 0; i < 2; i++) { [NSThread sleepForTimeInterval:2]; // 模拟耗时操作 NSLog(@"3---%d---%@",i, [NSThread currentThread]); // 打印当前线程 } }]; // 添加额外的操作 [op addExecutionBlock:^{ for (int i = 0; i < 2; i++) { [NSThread sleepForTimeInterval:2]; // 模拟耗时操作 NSLog(@"%d---%@",i, [NSThread currentThread]); // 打印当前线程 } }]; // 添加额外的操作 [op addExecutionBlock:^{ for (int i = 0; i < 2; i++) { [NSThread sleepForTimeInterval:2]; // 模拟耗时操作 NSLog(@"4---%d---%@",i, [NSThread currentThread]); // 打印当前线程 } }]; // 添加额外的操作 [op addExecutionBlock:^{ for (int i = 0; i < 2; i++) { [NSThread sleepForTimeInterval:2]; // 模拟耗时操作 NSLog(@"5---%d---%@",i, [NSThread currentThread]); // 打印当前线程 } }]; // 添加额外的操作 [op addExecutionBlock:^{ for (int i = 0; i < 2; i++) { [NSThread sleepForTimeInterval:2]; // 模拟耗时操作 NSLog(@"6---%d---%@",i, [NSThread currentThread]); // 打印当前线程 } }]; // 添加额外的操作 [op addExecutionBlock:^{ for (int i = 0; i < 2; i++) { [NSThread sleepForTimeInterval:2]; // 模拟耗时操作 NSLog(@"7---%d---%@",i, [NSThread currentThread]); // 打印当前线程 } }]; // 开始执行操作 [op start]; }输出为：
2020-03-18 13:21:41.725353+0800 多线程[13500:836712] 1---0---<NSThread: 0x6000005960c0>{number = 1, name = main} 2020-03-18 13:21:41.725358+0800 多线程[13500:897480] 0---<NSThread: 0x6000005f4c80>{number = 9, name = (null)} 2020-03-18 13:21:41.725362+0800 多线程[13500:897481] 3---0---<NSThread: 0x6000005ec200>{number = 8, name = (null)} 2020-03-18 13:21:41.725460+0800 多线程[13500:836759] 2---0---<NSThread: 0x6000005ede40>{number = 7, name = (null)} 2020-03-18 13:21:43.726334+0800 多线程[13500:897481] 3---1---<NSThread: 0x6000005ec200>{number = 8, name = (null)} 2020-03-18 13:21:43.726334+0800 多线程[13500:836712] 1---1---<NSThread: 0x6000005960c0>{number = 1, name = main} 2020-03-18 13:21:43.726334+0800 多线程[13500:897480] 1---<NSThread: 0x6000005f4c80>{number = 9, name = (null)} 2020-03-18 13:21:43.726334+0800 多线程[13500:836759] 2---1---<NSThread: 0x6000005ede40>{number = 7, name = (null)} 2020-03-18 13:21:45.727175+0800 多线程[13500:897480] 7---0---<NSThread: 0x6000005f4c80>{number = 9, name = (null)} 2020-03-18 13:21:45.727175+0800 多线程[13500:836712] 5---0---<NSThread: 0x6000005960c0>{number = 1, name = main} 2020-03-18 13:21:45.727175+0800 多线程[13500:897481] 4---0---<NSThread: 0x6000005ec200>{number = 8, name = (null)} 2020-03-18 13:21:45.727177+0800 多线程[13500:836759] 6---0---<NSThread: 0x6000005ede40>{number = 7, name = (null)} 2020-03-18 13:21:47.727933+0800 多线程[13500:897480] 7---1---<NSThread: 0x6000005f4c80>{number = 9, name = (null)} 2020-03-18 13:21:47.727933+0800 多线程[13500:897481] 4---1---<NSThread: 0x6000005ec200>{number = 8, name = (null)} 2020-03-18 13:21:47.727933+0800 多线程[13500:836759] 6---1---<NSThread: 0x6000005ede40>{number = 7, name = (null)} 2020-03-18 13:21:47.727933+0800 多线程[13500:836712] 5---1---<NSThread: 0x6000005960c0>{number = 1, name = main}可以看出：使用子类
NSBlockOperation，并调用addExecutionBlock:的情况下，blockOperationWithBlock :方法中的操作和addExecutionBlock :中的操作是在不同的线程中异步执行的。而且，当次执行结果中blockOperationWithBlock :方法中的操作也不是咱当前线程（主线程）中执行的。从而验证了blockOperationWithBlock:中的操作也可能会在其他线程（非当前线程）中执行。一般情况下，如果一个
NSBlockOperation对象封装了多个操作。NSBlockOperation是否会开启新线程，取决于操作的个数。如果添加的操作的个数多，就会开启新线程。开启的线程数是由系统来决定的。 -
自定义继承 NSOperation 的子类
如果使用子类NSInvocationOperation，NSBlockOperation不能满足日常需求，我们可以使用自定义继承自NSOperation的子类。可以通过重写main或者start方法来定义自己的 NSOperation 对象。重写main方法比较简单，我们不需要管理操作的状态属性isExecuting和isFinished。当main执行完返回的时候，这个操作就结束了。先定义一个继承自
NSOperation的子类，重写main方法。#import "CSOperation.h" @implementation CSOperation - (void)main { if (!self.isCancelled) { for (int i = 0; i < 2; i++) { [NSThread sleepForTimeInterval:2]; // 模拟耗时操作 NSLog(@"%d---%@",i, [NSThread currentThread]); // 打印当前线程 } } } @end然后开始使用自定义操作
/** 使用自定义继承自 NSOperation 的子类 */ - (void)useCustomOperation { CSOperation *op = [[CSOperation alloc] init]; [op start]; }输出结果为：
2020-03-18 14:06:29.449664+0800 多线程[14687:925436] <NSThread: 0x600003dc6800>{number = 1, name = main} 2020-03-18 14:06:31.451086+0800 多线程[14687:925436] <NSThread: 0x600003dc6800>{number = 1, name = main}可以看出：在没有使用
NSOperationQueue，在主线程单独使用自定义继承自NSOperation的子类的情况下，是在主线程执行操作，并没有开启新线程。
2. 创建队列：
NSOperationQueue一共有两种队列，主队列，自定义队列。其中自定义队列同时包含了串行，并发功能。
-
主队列：
凡是添加到主队列中的操作，都会放到主线程中执行。// 主队列获取方法 NSOperationQueue *queue = [NSOperationQueue mainQueue]; -
自定义队列（非主队列）
添加到这种队列中的操作，就会自动放到子线程中执行
同时包含了串行，并发功能。// 1.创建队列 NSOperationQueue *queue = [[NSOperationQueue alloc] init];
3. 将操作加入到队列中：
上面我们说到NSOperation需要配合NSOperationQueue来实现多线程
那么我们需要将创建的操作加入到队列中去，总共有两种方法。
-
-(void)addOperation:(NSOperation *)op;
需要先创建操作，再将创建好的操作加入到创建好的队列中去。/** 将操作添加到操作队列中 */ - (void)addOperationToQueue { // 1.创建队列 NSOperationQueue *queue = [[NSOperationQueue alloc] init]; // 2.创建操作 NSInvocationOperation *op1 = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(task1) object:nil]; NSInvocationOperation *op2 = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(task2) object:nil]; NSBlockOperation *op3 = [NSBlockOperation blockOperationWithBlock:^{ for (int i = 0; i < 2; i++) { [NSThread sleepForTimeInterval:2]; // 模拟耗时操作 NSLog(@"3---%d---%@",i, [NSThread currentThread]); // 打印当前线程 } }]; [op3 addExecutionBlock:^{ for (int i = 0; i < 2; i++) { [NSThread sleepForTimeInterval:2]; // 模拟耗时操作 NSLog(@"4---%d---%@",i, [NSThread currentThread]); // 打印当前线程 } }]; // 添加操作到队列中 [queue addOperation:op1]; [queue addOperation:op2]; [queue addOperation:op3]; }输出结果为：
2020-03-18 14:53:42.714002+0800 多线程[15088:956676] 4---0---<NSThread: 0x600002451b40>{number = 8, name = (null)} 2020-03-18 14:53:42.714004+0800 多线程[15088:956133] task1---0---<NSThread: 0x600002454f40>{number = 3, name = (null)} 2020-03-18 14:53:42.714002+0800 多线程[15088:956675] 3---0---<NSThread: 0x600002465a40>{number = 9, name = (null)} 2020-03-18 14:53:42.714002+0800 多线程[15088:956674] task2---0---<NSThread: 0x600002468580>{number = 10, name = (null)} 2020-03-18 14:53:44.718627+0800 多线程[15088:956133] task1---1---<NSThread: 0x600002454f40>{number = 3, name = (null)} 2020-03-18 14:53:44.718616+0800 多线程[15088:956676] 4---1---<NSThread: 0x600002451b40>{number = 8, name = (null)} 2020-03-18 14:53:44.718667+0800 多线程[15088:956674] task2---1---<NSThread: 0x600002468580>{number = 10, name = (null)} 2020-03-18 14:53:44.718660+0800 多线程[15088:956675] 3---1---<NSThread: 0x600002465a40>{number = 9, name = (null)}可以看出：使用
NSOperation子类创建操作，并使用addOperation:，将操作加入到NSOperationQueue操作队列后能够开启新线程，进行并发执行。 -
-(void)addOperationWithBlock:(void (^)(void))block;
无需先创建操作，在 block 添加操作，直接将包含操作的 block 加入到队列中。/** 使用 addOperationWithBlock: 将操作加入到操作队列中 */ - (void)addOperationWithBlockToQueue { // 创建队列 NSOperationQueue *queue = [[NSOperationQueue alloc] init]; // 使用 addOperationWithBlock添加操作到队列中 [queue addOperationWithBlock:^{ for (int i = 0; i < 2; i++) { [NSThread sleepForTimeInterval:2]; // 模拟耗时操作 NSLog(@"1---%d---%@",i, [NSThread currentThread]); // 打印当前线程 } }]; [queue addOperationWithBlock:^{ for (int i = 0; i < 2; i++) { [NSThread sleepForTimeInterval:2]; // 模拟耗时操作 NSLog(@"2---%d---%@",i, [NSThread currentThread]); // 打印当前线程 } }]; [queue addOperationWithBlock:^{ for (int i = 0; i < 2; i++) { [NSThread sleepForTimeInterval:2]; // 模拟耗时操作 NSLog(@"3---%d---%@",i, [NSThread currentThread]); // 打印当前线程 } }]; }输出结果为：
2020-03-18 15:09:24.090062+0800 多线程[15207:965085] 2---0---<NSThread: 0x6000009dcc00>{number = 8, name = (null)} 2020-03-18 15:09:24.090062+0800 多线程[15207:965080] 1---0---<NSThread: 0x6000009f5e40>{number = 3, name = (null)} 2020-03-18 15:09:24.090062+0800 多线程[15207:966846] 3---0---<NSThread: 0x6000009c1440>{number = 9, name = (null)} 2020-03-18 15:09:26.093838+0800 多线程[15207:966846] 3---1---<NSThread: 0x6000009c1440>{number = 9, name = (null)} 2020-03-18 15:09:26.093838+0800 多线程[15207:965085] 2---1---<NSThread: 0x6000009dcc00>{number = 8, name = (null)} 2020-03-18 15:09:26.093893+0800 多线程[15207:965080] 1---1---<NSThread: 0x6000009f5e40>{number = 3, name = (null)}可以看出：使用
addOperationWithBlock:将操作加入到操作队列后能够开启新线程，进行并发执行。
NSOperationQueue控制串行执行，并发执行
上面我们说过，NSOperationQueue创建的自定义队列同时具备串行，并发功能，上面我们演示了并发功能，那么其他的串行功能如何实现的？
这里有个关键属性maxConcurrentOperationCount,叫做最大并发操作数，用来控制一个特定队列中可以有多少个操作同时参与并发执行。
注意：这里maxConcurrentOperationCount控制的不是并发线程的数量，而是一个队列中同时能并发执行的最大操作数。而且一个操作也并非只能在一个线程中运行。
- 最大并发操作数:
maxConcurrentOperationCount-
maxConcurrentOperationCount默认情况下为-1，表示不进行限制，可进行并发执行 -
maxConcurrentOperationCount为1时，队列为串行队列。只能串行执行。 -
maxConcurrentOperationCount为大于1时，队列为并发队列。操作并发执行，当然这个值不应超过系统限制，即使自己设置一个很大的值，系统也会自动调整为设定的默认最大值。
/** 设置 MaxConcurrentOperationCount（最大并发操作数） */ - (void)addMaxConcurrentOperationCount { // 创建队列 NSOperationQueue *queue = [[NSOperationQueue alloc] init]; // 设置对的并发数 queue.maxConcurrentOperationCount = 1; // 串行队列 // queue.maxConcurrentOperationCount = 2; // 并行队列 // queue.maxConcurrentOperationCount = 9; // 并行队列 // 使用 addOperationWithBlock添加操作到队列中 [queue addOperationWithBlock:^{ for (int i = 0; i < 2; i++) { [NSThread sleepForTimeInterval:2]; // 模拟耗时操作 NSLog(@"1---%d---%@",i, [NSThread currentThread]); // 打印当前线程 } }]; [queue addOperationWithBlock:^{ for (int i = 0; i < 2; i++) { [NSThread sleepForTimeInterval:2]; // 模拟耗时操作 NSLog(@"2---%d---%@",i, [NSThread currentThread]); // 打印当前线程 } }]; [queue addOperationWithBlock:^{ for (int i = 0; i < 2; i++) { [NSThread sleepForTimeInterval:2]; // 模拟耗时操作 NSLog(@"3---%d---%@",i, [NSThread currentThread]); // 打印当前线程 } }]; [queue addOperationWithBlock:^{ for (int i = 0; i < 2; i++) { [NSThread sleepForTimeInterval:2]; // 模拟耗时操作 NSLog(@"4---%d---%@",i, [NSThread currentThread]); // 打印当前线程 } }]; }- 最大并发操作数为1时输出结果为：
2020-03-18 15:36:57.116058+0800 多线程[15407:981519] 1---0---<NSThread: 0x60000094fbc0>{number = 5, name = (null)} 2020-03-18 15:36:59.120134+0800 多线程[15407:981519] 1---1---<NSThread: 0x60000094fbc0>{number = 5, name = (null)} 2020-03-18 15:37:01.124916+0800 多线程[15407:981519] 2---0---<NSThread: 0x60000094fbc0>{number = 5, name = (null)} 2020-03-18 15:37:03.129369+0800 多线程[15407:981519] 2---1---<NSThread: 0x60000094fbc0>{number = 5, name = (null)} 2020-03-18 15:37:05.131704+0800 多线程[15407:985380] 3---0---<NSThread: 0x600000971cc0>{number = 8, name = (null)} 2020-03-18 15:37:07.135591+0800 多线程[15407:985380] 3---1---<NSThread: 0x600000971cc0>{number = 8, name = (null)} 2020-03-18 15:37:09.137144+0800 多线程[15407:981519] 4---0---<NSThread: 0x60000094fbc0>{number = 5, name = (null)} 2020-03-18 15:37:11.138100+0800 多线程[15407:981519] 4---1---<NSThread: 0x60000094fbc0>{number = 5, name = (null)} - 最大并发操作数为2时输出结果为：
2020-03-18 15:42:36.240302+0800 多线程[15510:989399] 1---0---<NSThread: 0x600003042800>{number = 3, name = (null)} 2020-03-18 15:42:36.240325+0800 多线程[15510:989755] 2---0---<NSThread: 0x6000030707c0>{number = 8, name = (null)} 2020-03-18 15:42:38.245564+0800 多线程[15510:989755] 2---1---<NSThread: 0x6000030707c0>{number = 8, name = (null)} 2020-03-18 15:42:38.245575+0800 多线程[15510:989399] 1---1---<NSThread: 0x600003042800>{number = 3, name = (null)} 2020-03-18 15:42:40.248316+0800 多线程[15510:989755] 3---0---<NSThread: 0x6000030707c0>{number = 8, name = (null)} 2020-03-18 15:42:40.248316+0800 多线程[15510:989815] 4---0---<NSThread: 0x600003078c40>{number = 9, name = (null)} 2020-03-18 15:42:42.250296+0800 多线程[15510:989755] 3---1---<NSThread: 0x6000030707c0>{number = 8, name = (null)} 2020-03-18 15:42:42.250296+0800 多线程[15510:989815] 4---1---<NSThread: 0x600003078c40>{number = 9, name = (null)} - 最大并发操作数为9时输出结果为：
2020-03-18 15:43:52.453101+0800 多线程[15538:990835] 1---0---<NSThread: 0x6000009cf740>{number = 3, name = (null)} 2020-03-18 15:43:52.453101+0800 多线程[15538:991155] 3---0---<NSThread: 0x6000009e8400>{number = 8, name = (null)} 2020-03-18 15:43:52.453101+0800 多线程[15538:991154] 2---0---<NSThread: 0x6000009f8d80>{number = 9, name = (null)} 2020-03-18 15:43:52.453101+0800 多线程[15538:991156] 4---0---<NSThread: 0x6000009ecd80>{number = 7, name = (null)} 2020-03-18 15:43:54.458062+0800 多线程[15538:990835] 1---1---<NSThread: 0x6000009cf740>{number = 3, name = (null)} 2020-03-18 15:43:54.458065+0800 多线程[15538:991156] 4---1---<NSThread: 0x6000009ecd80>{number = 7, name = (null)} 2020-03-18 15:43:54.458110+0800 多线程[15538:991155] 3---1---<NSThread: 0x6000009e8400>{number = 8, name = (null)} 2020-03-18 15:43:54.458112+0800 多线程[15538:991154] 2---1---<NSThread: 0x6000009f8d80>{number = 9, name = (null)}
-
NSOperation 操作依赖
NSOperation、NSOperationQueue 最吸引人的地方是它能添加操作之间的依赖关系。通过操作依赖，我们可以很方便的控制操作之间的执行先后顺序。NSOperation 提供了3个接口供我们管理和查看依赖。
-
- (void)addDependency:(NSOperation *)op;添加依赖，使当前操作依赖于操作 op 的完成 -
- (void)removeDependency:(NSOperation *)op;移除依赖，取消当前操作对象操作 op 的依赖 -
@property (readonly, copy) NSArray<NSOperation *> *dependencies;在当前操作开始执行之前，完成执行的所有操作对象数组。
现有一个需求，有 A，B 两个需求，其中 A 执行完操作，B 才能执行操作。
如果使用依赖来处理的话，那么就需要让操作 B 依赖于操作 A。代码如下
/**
添加操作依赖
*/
- (void)addDependency {
// 创建队列
NSOperationQueue *queue = [[NSOperationQueue alloc] init];
// 创建操作
NSBlockOperation *op1 = [NSBlockOperation blockOperationWithBlock:^{
for (int i = 0; i < 2; i++) {
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"1---%d---%@",i, [NSThread currentThread]); // 打印当前线程
}
}];
NSBlockOperation *op2 = [NSBlockOperation blockOperationWithBlock:^{
for (int i = 0; i < 2; i++) {
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"2---%d---%@",i, [NSThread currentThread]); // 打印当前线程
}
}];
// 添加依赖
[op2 addDependency:op1]; // 让 op2依赖于 op1.则先执行 op1，再执行 op2
// 添加操作到队列中
[queue addOperation:op1];
[queue addOperation:op2];
}
输出结果为：
2020-03-18 15:56:52.028698+0800 多线程[15645:999754] 1---0---<NSThread: 0x600002cc34c0>{number = 3, name = (null)}
2020-03-18 15:56:54.030698+0800 多线程[15645:999754] 1---1---<NSThread: 0x600002cc34c0>{number = 3, name = (null)}
2020-03-18 15:56:56.035021+0800 多线程[15645:999754] 2---0---<NSThread: 0x600002cc34c0>{number = 3, name = (null)}
2020-03-18 15:56:58.040238+0800 多线程[15645:999754] 2---1---<NSThread: 0x600002cc34c0>{number = 3, name = (null)}
可以看出：通过添加操作依赖，无论运行 n 多次，其结果都是 op1先执行，op2后执行。
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 都不是准备就绪状态下的操作。
理解了进入就绪状态的操作，那么我们就理解了queuePriority属性的作用对象。
-
queuePriority属性决定了进入准备就绪状态下的操作之间的开始执行顺序。并且，优先级不能取代依赖关系。 - 如果一个队列中既包含
高优先级操作，又包含低优先级操作，并且两个操作都已经准备就绪，那么队列先执行高优先级操作。比如上例中，如果 op1 和 op4 是不同优先级的操作，那么就会先执行优先级高的操作。 - 如果，一个队列中既包含了
准备就绪状态的操作，又包含了未准备就绪的操作，未准备就绪的操作优先级比准备就绪的操作优先级高。那么，虽然准备就绪的操作优先级低，也会优先执行。优先级不能取代依赖关系。如果要控制操作间的启动顺序，则必须使用依赖关系。
NSOperation，NSOperationQueue 线程间的通信
在 iOS 开发过程中，我们一般在主线程里边进行 UI 刷新，例如：点击、滚动、拖拽等事件。我们通常把一些耗时的操作放在其他线程，比如说图片下载、文件上传等耗时操作。而当我们有时候在其他线程完成了耗时操作时，需要回到主线程，那么就用到了线程之间的通讯。
/**
线程间通信
*/
- (void)communication {
// 创建队列
NSOperationQueue *queue = [[NSOperationQueue alloc] init];
// 添加操作
[queue addOperationWithBlock:^{
// 异步执行耗时操作
for (int i = 0; i < 2; i++) {
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"1---%d---%@",i, [NSThread currentThread]); // 打印当前线程
}
// 回到主线程
[[NSOperationQueue mainQueue] addOperationWithBlock:^{
for (int i = 0; i < 2; i++) {
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"2---%d---%@",i, [NSThread currentThread]); // 打印当前线程
}
}];
}];
}
输出结果为：
2020-03-18 16:26:54.990224+0800 多线程[15909:1020280] 1---0---<NSThread: 0x6000031bee00>{number = 3, name = (null)}
2020-03-18 16:26:56.992269+0800 多线程[15909:1020280] 1---1---<NSThread: 0x6000031bee00>{number = 3, name = (null)}
2020-03-18 16:26:58.993433+0800 多线程[15909:1020170] 2---0---<NSThread: 0x6000031e10c0>{number = 1, name = main}
2020-03-18 16:27:00.994794+0800 多线程[15909:1020170] 2---1---<NSThread: 0x6000031e10c0>{number = 1, name = main}
可以看出：通过线程间的通信，先在其他线程中执行操作，等操作执行完了之后再回到主线程执行主线程的相应操作。
NSOperation、NSOperationQueue 线程同步和线程安全
- 线程安全：
如果你的代码所在的进程中有多个线程在同时运行，而这些线程可能会同时运行这段代码。如果每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。 - 线程不安全：
若每个线程中对全局变量、静态变量只有读操作，而无写操作，一般来说，这个全局变量是线程安全的；若有多个线程同时执行写操作（更改变量），一般都需要考虑线程同步，否则的话就可能影响线程安全。 - 线程同步：
可理解为线程 A 和 线程 B 一块配合，A 执行到一定程度时要依靠线程 B 的某个结果，于是停下来，示意 B 运行；B 依言执行，再将结果给 A；A 再继续操作。
举个简单例子就是：两个人在一起聊天。两个人不能同时说话，避免听不清(操作冲突)。等一个人说完(一个线程结束操作)，另一个再说(另一个线程再开始操作)。
下面，我们模拟火车票售卖的方式，实现 NSOperation 线程安全和解决线程同步问题。
场景：总共有40张火车票，有两个售卖火车票的窗口，一个是广州火车票售卖窗口，另一个是龙岩火车票售卖窗口。两个窗口同时售卖火车票，卖完为止
-
线程不安全：
输出结果为：/** * 初始化火车票数量、卖票窗口(非线程安全)、并开始卖票 * 非线程安全：不加锁-NSLock */ - (void)initTicketStatusNotSave { NSLog(@"currentThread---%@",[NSThread currentThread]); // 打印当前线程 _ticketSurplusCount = 40; // 1.创建 queue1,queue1 代表广州火车票售卖窗口 NSOperationQueue *queue1 = [[NSOperationQueue alloc] init]; queue1.maxConcurrentOperationCount = 1; // 2.创建 queue2,queue2 代表龙岩火车票售卖窗口 NSOperationQueue *queue2 = [[NSOperationQueue alloc] init]; queue2.maxConcurrentOperationCount = 1; // 3.创建卖票操作 op1 __weak typeof(self) weakSelf = self; NSBlockOperation *op1 = [NSBlockOperation blockOperationWithBlock:^{ [weakSelf saleTicketNotSafe]; }]; // 4.创建卖票操作 op2 NSBlockOperation *op2 = [NSBlockOperation blockOperationWithBlock:^{ [weakSelf saleTicketNotSafe]; }]; // 5.添加操作，开始卖票 [queue1 addOperation:op1]; [queue2 addOperation:op2]; } /** 售卖火车票 */ - (void)saleTicketNotSafe { while (1) { if (_ticketSurplusCount > 0) { // 如果还有票，就接着卖) _ticketSurplusCount--; NSLog(@"%@", [NSString stringWithFormat:@"剩余票数:%d 窗口:%@", _ticketSurplusCount, [NSThread currentThread]]); [NSThread sleepForTimeInterval:0.2]; } else { NSLog(@"所有火车票均已售完"); break; } } }image.png
image.png
可以看出：在不考虑线程安全，不使用加锁情况下，得到的票是错乱的，这样明显不符合我们的需求，所以需要考虑线程安全问题。
-
线程安全：
可以给线程加锁，在一个线程执行该操作的时候，不允许其他线程进行操作。iOS 实现线程加锁有很多种方式。@synchronized、 NSLock、NSRecursiveLock、NSCondition、NSConditionLock、pthread_mutex、dispatch_semaphore、OSSpinLock、atomic(property) set/ge等等各种方式。这里我们使用 NSLock 对象来解决线程同步问题。NSLock 对象可以通过进入锁时调用 lock 方法，解锁时调用 unlock 方法来保证线程安全。
输出结果为：/** * 初始化火车票数量、卖票窗口(线程安全)、并开始卖票 * 线程安全：加锁-NSLock */ - (void)initTicketStatusSave { NSLog(@"currentThread---%@",[NSThread currentThread]); // 打印当前线程 _ticketSurplusCount = 50; _lock = [[NSLock alloc] init]; // 1.创建 queue1,queue1 代表广州火车票售卖窗口 NSOperationQueue *queue1 = [[NSOperationQueue alloc] init]; queue1.maxConcurrentOperationCount = 1; // 2.创建 queue2,queue2 代表龙岩火车票售卖窗口 NSOperationQueue *queue2 = [[NSOperationQueue alloc] init]; queue2.maxConcurrentOperationCount = 1; // 3.创建卖票操作 op1 __weak typeof(self) weakSelf = self; NSBlockOperation *op1 = [NSBlockOperation blockOperationWithBlock:^{ [weakSelf saleTicketSafe]; }]; // 4.创建卖票操作 op2 NSBlockOperation *op2 = [NSBlockOperation blockOperationWithBlock:^{ [weakSelf saleTicketSafe]; }]; // 5.添加操作，开始卖票 [queue1 addOperation:op1]; [queue2 addOperation:op2]; } /** 售卖火车票 */ - (void)saleTicketSafe { while (1) { [_lock lock]; if (_ticketSurplusCount > 0) { // 如果还有票，就接着卖) _ticketSurplusCount--; NSLog(@"%@", [NSString stringWithFormat:@"剩余票数:%d 窗口:%@", _ticketSurplusCount, [NSThread currentThread]]); [NSThread sleepForTimeInterval:0.2]; } [_lock unlock]; if (_ticketSurplusCount <= 0) { NSLog(@"所有火车票均已售完"); break; } } }image.png
可以看出：在考虑了线程安全，使用 NSLock 加锁，解锁机制的情况下，得到的票数是正确的，没有出现混乱的情况。即解决了多个线程同步的问题。
NSOperation 常用属性和方法：
-
取消操作方法
-
(void)cancel;可取消操作，实质是标记 isCancelled 状态。
-
-
判断操作状态方法
-
(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 常用属性和方法：
-
取消/暂停/恢复操作
-
(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;获取主队列。
-
注意：
1.1 这里的暂停和取消（包括操作的取消和队列的取消）并不代表可以将当前的操作立即取消，而是当当前的操作执行完毕之后不再执行新的操作
1.2 暂停和取消的区别在于：暂停操作之后还可以恢复操作，继续向下执行；而取消操作之后，所有的操作都清空了，无法再接着执行剩下的操作。
