1.简介
NSOperation、NSOperationQueue是基于GCD的封装，完全面向对象。比GCD更为简单，代码可读性也高了不少。
NSOperation和NSOperationQueue有不少有点，如下
- 可以添加完成代码，在操作完成后执行
- 可以添加操作之间的顺序
- 设定操作之间的优先级
- 可以方便的取消操作
- 可以观察操作执行状态:isCancelled, isAsynchronous, isExecuting, isFinished, isReady等等
既然是基于GCD封装的，那么有些概念还是可以套用一下的。比如操作对应任务，
队列对应操作队列
-
操作
- 执行操作就是在线程中执行代码
- 使用NSOperation的子类
NSInvocationOperation,NSBlockOperation,或者自定义子类来封装操作
-
操作队列
- 操作队列就是存放操作的队列，但是和GCD的队列不一样，不遵循FIFO原则。首先通过依赖关系（dependencies）进入准备就绪状态（ready）。依赖关系是绝对的，哪怕是多线程情况下，也会等待之前的依赖线程执行完才能执行当前操作。
- 操作队列通过设置最大并发操作数（maxConcurrentOperationCount）来控制并发，串行
- NSOperationQueue提供了两种类型的队列，一种是主队列和自定义队列。主队列运行在主线程上，自定义队列在后台执行。
2.使用步骤
NSOperation操作步骤
- 创建操作：将要执行的操作封装到一个NSOperation对象中。
- 创建队列：创建NSOperationQueue对象
- 将操作添加到队列中：将NSOperation对象添加到NSOperationQueue中
2.1 创建操作
NSOperation是一个抽象类，需要我们使用它的子类。有以下三种选择：
- NSInvocationOperation
- NSBlockOperation
- 自定义继承自NSOperation的子类，实现相应方法来封装操作
2.1.1 NSInvocationOperation
- (void)invocation{
NSInvocationOperation *op = [[NSInvocationOperation alloc]initWithTarget:self selector:@selector(task) object:nil];
[op start];
}
- (void)task1{
for (int i = 0; i < 2; i++) {
[NSThread sleepForTimeInterval:2];
NSLog(@"1---%@", [NSThread currentThread]);
}
}
2018-05-17 14:17:02.903373+0800 MultiThread[13966:1261901] 1---<NSThread: 0x604000074f80>{number = 1, name = main}
2018-05-17 14:17:04.905077+0800 MultiThread[13966:1261901] 1---<NSThread: 0x604000074f80>{number = 1, name = main}
[NSThread detachNewThreadSelector:@selector(invocation) toTarget:self withObject:nil];
2018-05-17 14:17:44.535875+0800 MultiThread[13991:1263666] 1---<NSThread: 0x60000046de80>{number = 3, name = (null)}
2018-05-17 14:17:46.541399+0800 MultiThread[13991:1263666] 1---<NSThread: 0x60000046de80>{number = 3, name = (null)}
不使用NSOperationQueue，会直接在主线程中执行操作，不会创建新线程。如果在其他线程中执行，就会打印其他线程
2.1.2 NSBlockOperation
- (void)block{
NSBlockOperation *op = [NSBlockOperation blockOperationWithBlock:^{
for (int i = 0; i < 2; i++) {
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"1---%@", [NSThread currentThread]); // 打印当前线程
}
}];
[op start];
}
2018-05-17 14:20:32.340855+0800 MultiThread[14056:1269157] 1---<NSThread: 0x60400006f140>{number = 1, name = main}
2018-05-17 14:20:34.342273+0800 MultiThread[14056:1269157] 1---<NSThread: 0x60400006f140>{number = 1, name = main}
NSBlockOperation提供了一个方法addExecutionBlock，通过这个方法，就能为NSBlockOperation添加额外的操作，只有在blockOperationWithBlock和addExecutionBlock中的操作全部完成后，才算完成。如果添加的操作过多，系统有可能会开启新的线程来完成操作。
- (void)block{
NSBlockOperation *op = [NSBlockOperation blockOperationWithBlock:^{
for (int i = 0; i < 2; i++) {
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"1---%@", [NSThread currentThread]); // 打印当前线程
}
}];
[op addExecutionBlock:^{
for (int i = 0; i < 2; i++) {
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"2---%@", [NSThread currentThread]); // 打印当前线程
}
}];
[op addExecutionBlock:^{
for (int i = 0; i < 2; i++) {
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"3---%@", [NSThread currentThread]); // 打印当前线程
}
}];
[op addExecutionBlock:^{
for (int i = 0; i < 2; i++) {
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"4---%@", [NSThread currentThread]); // 打印当前线程
}
}];
[op addExecutionBlock:^{
for (int i = 0; i < 2; i++) {
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"5---%@", [NSThread currentThread]); // 打印当前线程
}
}];
[op addExecutionBlock:^{
for (int i = 0; i < 2; i++) {
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"6---%@", [NSThread currentThread]); // 打印当前线程
}
}];
[op start];
}
- (void)invocation{
NSInvocationOperation *op = [[NSInvocationOperation alloc]initWithTarget:self selector:@selector(task1) object:nil];
[op start];
}
2018-05-17 14:28:06.052693+0800 MultiThread[14158:1281194] 1---<NSThread: 0x60400007ff40>{number = 1, name = main}
2018-05-17 14:28:06.052693+0800 MultiThread[14158:1281347] 3---<NSThread: 0x600000467600>{number = 3, name = (null)}
2018-05-17 14:28:06.052698+0800 MultiThread[14158:1281349] 2---<NSThread: 0x6040004727c0>{number = 4, name = (null)}
2018-05-17 14:28:06.052795+0800 MultiThread[14158:1281348] 4---<NSThread: 0x600000467500>{number = 5, name = (null)}
2018-05-17 14:28:08.054454+0800 MultiThread[14158:1281194] 1---<NSThread: 0x60400007ff40>{number = 1, name = main}
2018-05-17 14:28:08.054454+0800 MultiThread[14158:1281347] 3---<NSThread: 0x600000467600>{number = 3, name = (null)}
2018-05-17 14:28:08.054454+0800 MultiThread[14158:1281349] 2---<NSThread: 0x6040004727c0>{number = 4, name = (null)}
2018-05-17 14:28:08.054525+0800 MultiThread[14158:1281348] 4---<NSThread: 0x600000467500>{number = 5, name = (null)}
2018-05-17 14:28:10.055459+0800 MultiThread[14158:1281194] 6---<NSThread: 0x60400007ff40>{number = 1, name = main}
2018-05-17 14:28:10.055531+0800 MultiThread[14158:1281347] 5---<NSThread: 0x600000467600>{number = 3, name = (null)}
2018-05-17 14:28:12.056989+0800 MultiThread[14158:1281194] 6---<NSThread: 0x60400007ff40>{number = 1, name = main}
2018-05-17 14:28:12.056989+0800 MultiThread[14158:1281347] 5---<NSThread: 0x600000467600>{number = 3, name = (null)}
打印结果可以看出：AddExecutionBlock和blockOperationWithBlock两者是在不同的线程中执行的。所以如果任务过多，是有可能会开启新线程的。另外，blockOperationWithBlock的操作有可能还在开启的新线程执行。
2.1.3 使用自定义的NSOperation子类
当系统提供的两个子类不能满足我们的要求时，我们可以通过自定义继承自NSOperation的子类。重写main和start方法来定义自己的NSOperation对象。
//CusOperation.h
#import <Foundation/Foundation.h>
@interface CusOperation : NSOperation
@end
//CusOperation.m
#import "CusOperation.h"
@implementation CusOperation
- (void)main{
if (!self.isCancelled) {
for (int i = 0; i < 2; i++) {
[NSThread sleepForTimeInterval:2];
NSLog(@"1---%@", [NSThread currentThread]);
}
}
}
@end
- (void)customOperation{
CusOperation *op = [[CusOperation alloc]init];
[op start];
}
2018-05-17 14:38:16.129219+0800 MultiThread[14331:1299438] 1---<NSThread: 0x600000079340>{number = 1, name = main}
2018-05-17 14:38:18.129706+0800 MultiThread[14331:1299438] 1---<NSThread: 0x600000079340>{number = 1, name = main}
以上示例可以看出：
在没有使用 NSOperationQueue、在主线程单独使用自定义继承自 NSOperation 的子类的情况下，是在主线程执行操作，并没有开启新线程
2.2 创建队列
NSOperationQueue有两种队列：主队列和自定义队列。自定义队列包含了串行、并发功能。
- 主队列
- 添加到主队列的操作，都会方法哦主线程中执行。
NSOperationQueue *queue = [NSOperationQueue mainQueue];
- 自定义队列
- 添加到该队列的操作，会自动放到子线程中执行
- 同时包含了串行，并发功能
// 自定义队列创建方法
NSOperationQueue *queue = [[NSOperationQueue alloc] init];
2.3 将操作添加到队列中
将操作添加到操作队列中区，有两种方法：
-
- (void)addOperation:(NSOperation *)op;
先创建操作，再讲创建好的操作添加到创建好的队列中去
- (void)addOperationToQueue{
NSOperationQueue *queue = [[NSOperationQueue alloc]init];
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---%@", [NSThread currentThread]); // 打印当前线程
}
}];
[op3 addExecutionBlock:^{
for (int i = 0; i < 2; i++) {
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"Finished --- %@", [NSThread currentThread]); // 打印当前线程
}
}];
[queue addOperation:op1];
[queue addOperation:op2];
[queue addOperation:op3];
}
-
- (void)addOperationWithBlock:(void (^)(void))block;
不需要创建操作，在block中直接添加操作，直接将包含操作的block添加到队列中。
- (void)addOperationByBlock{
NSOperationQueue *queue = [[NSOperationQueue alloc] init];
// 2.使用 addOperationWithBlock: 添加操作到队列中
[queue addOperationWithBlock:^{
for (int i = 0; i < 2; i++) {
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"1---%@", [NSThread currentThread]); // 打印当前线程
}
}];
[queue addOperationWithBlock:^{
for (int i = 0; i < 2; i++) {
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"2---%@", [NSThread currentThread]); // 打印当前线程
}
}];
[queue addOperationWithBlock:^{
for (int i = 0; i < 2; i++) {
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"3---%@", [NSThread currentThread]); // 打印当前线程
}
}];
}
2018-05-17 15:09:17.220840+0800 MultiThread[14694:1339685] 1---<NSThread: 0x60400027ce40>{number = 3, name = (null)}
2018-05-17 15:09:17.220840+0800 MultiThread[14694:1338535] 3---<NSThread: 0x6000006652c0>{number = 4, name = (null)}
2018-05-17 15:09:17.220870+0800 MultiThread[14694:1339697] 2---<NSThread: 0x60400027e040>{number = 5, name = (null)}
2018-05-17 15:09:19.223380+0800 MultiThread[14694:1339685] 1---<NSThread: 0x60400027ce40>{number = 3, name = (null)}
2018-05-17 15:09:19.223399+0800 MultiThread[14694:1338535] 3---<NSThread: 0x6000006652c0>{number = 4, name = (null)}
2018-05-17 15:09:19.223464+0800 MultiThread[14694:1339697] 2---<NSThread: 0x60400027e040>{number = 5, name = (null)}
可以看出开启了新线程，并发执行。
3. NSOperationQueue控制串行，并行
最大并发操作数maxConcurrentOperationCount，可以用来控制一个特定队列中可以有多少个操作同时并发执行。
-
maxConcurrentOperationCount默认-1，表示不做限制，可以进行并发操作 -
maxConcurrentOperationCount等于1，队列为串行队列，只能串行执行 -
maxConcurrentOperationCount大于1时，队列为并发队列，可以进行并发执行
- (void)setMaxConcurrentOperationCount{
// 1.创建队列
NSOperationQueue *queue = [[NSOperationQueue alloc] init];
// 2.设置最大并发操作数
queue.maxConcurrentOperationCount = 1; // 串行队列
// queue.maxConcurrentOperationCount = 2; // 并发队列
// queue.maxConcurrentOperationCount = 6; // 并发队列
// 3.添加操作
[queue addOperationWithBlock:^{
for (int i = 0; i < 2; i++) {
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"1---%@", [NSThread currentThread]); // 打印当前线程
}
}];
[queue addOperationWithBlock:^{
for (int i = 0; i < 2; i++) {
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"2---%@", [NSThread currentThread]); // 打印当前线程
}
}];
[queue addOperationWithBlock:^{
for (int i = 0; i < 2; i++) {
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"3---%@", [NSThread currentThread]); // 打印当前线程
}
}];
}
设置maxConcurrentOperationCount等于1的时候。
2018-05-17 15:14:48.876623+0800 MultiThread[14777:1347945] 1---<NSThread: 0x600000461d40>{number = 3, name = (null)}
2018-05-17 15:14:50.879393+0800 MultiThread[14777:1347945] 1---<NSThread: 0x600000461d40>{number = 3, name = (null)}
2018-05-17 15:14:52.884111+0800 MultiThread[14777:1347942] 2---<NSThread: 0x60400007a980>{number = 4, name = (null)}
2018-05-17 15:14:54.888856+0800 MultiThread[14777:1347942] 2---<NSThread: 0x60400007a980>{number = 4, name = (null)}
2018-05-17 15:14:56.893411+0800 MultiThread[14777:1347945] 3---<NSThread: 0x600000461d40>{number = 3, name = (null)}
2018-05-17 15:14:58.895721+0800 MultiThread[14777:1347945] 3---<NSThread: 0x600000461d40>{number = 3, name = (null)}
设置maxConcurrentOperationCount等于2的时候。
2018-05-17 15:16:59.695592+0800 MultiThread[14819:1352085] 2---<NSThread: 0x600000663f40>{number = 3, name = (null)}
2018-05-17 15:16:59.695593+0800 MultiThread[14819:1352087] 1---<NSThread: 0x604000270f80>{number = 4, name = (null)}
2018-05-17 15:17:01.701006+0800 MultiThread[14819:1352087] 1---<NSThread: 0x604000270f80>{number = 4, name = (null)}
2018-05-17 15:17:01.701010+0800 MultiThread[14819:1352085] 2---<NSThread: 0x600000663f40>{number = 3, name = (null)}
2018-05-17 15:17:03.706541+0800 MultiThread[14819:1352088] 3---<NSThread: 0x60400027a640>{number = 5, name = (null)}
2018-05-17 15:17:05.711808+0800 MultiThread[14819:1352088] 3---<NSThread: 0x60400027a640>{number = 5, name = (null)}
设置maxConcurrentOperationCount等于6的时候。
2018-05-17 15:17:46.013273+0800 MultiThread[14843:1353840] 2---<NSThread: 0x600000462a00>{number = 5, name = (null)}
2018-05-17 15:17:46.013280+0800 MultiThread[14843:1353842] 1---<NSThread: 0x604000461780>{number = 4, name = (null)}
2018-05-17 15:17:46.013280+0800 MultiThread[14843:1353841] 3---<NSThread: 0x600000461c80>{number = 3, name = (null)}
2018-05-17 15:17:48.016936+0800 MultiThread[14843:1353842] 1---<NSThread: 0x604000461780>{number = 4, name = (null)}
2018-05-17 15:17:48.016936+0800 MultiThread[14843:1353840] 2---<NSThread: 0x600000462a00>{number = 5, name = (null)}
2018-05-17 15:17:48.016982+0800 MultiThread[14843:1353841] 3---<NSThread: 0x600000461c80>{number = 3, name = (null)}
4. NSOperation操作依赖
通过操作依赖，我们可以很轻松的控制操作执行顺序，有以下三个方法属性，帮助我们管理依赖关系。
-
- (void)addDependency:(NSOperation *)op;添加依赖，使当前操作依赖于操作 op 的完成。 -
- (void)removeDependency:(NSOperation *)op;移除依赖，取消当前操作对操作 op 的依赖。 -
@property (readonly, copy) NSArray<NSOperation *> *dependencies;在当前操作开始执行之前完成执行的所有操作对象数组。
- (void)addDependency {
// 1.创建队列
NSOperationQueue *queue = [[NSOperationQueue alloc] init];
// 2.创建操作
NSBlockOperation *op1 = [NSBlockOperation blockOperationWithBlock:^{
for (int i = 0; i < 2; i++) {
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"1---%@", [NSThread currentThread]); // 打印当前线程
}
}];
NSBlockOperation *op2 = [NSBlockOperation blockOperationWithBlock:^{
for (int i = 0; i < 2; i++) {
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"2---%@", [NSThread currentThread]); // 打印当前线程
}
}];
// 3.添加依赖
[op2 addDependency:op1]; // 让op2 依赖于 op1，则先执行op1，在执行op2
// 4.添加操作到队列中
[queue addOperation:op1];
[queue addOperation:op2];
}
2018-05-17 15:28:00.975331+0800 MultiThread[14961:1367884] 1---<NSThread: 0x60000027cac0>{number = 3, name = (null)}
2018-05-17 15:28:02.980260+0800 MultiThread[14961:1367884] 1---<NSThread: 0x60000027cac0>{number = 3, name = (null)}
2018-05-17 15:28:04.984993+0800 MultiThread[14961:1367885] 2---<NSThread: 0x60400027ccc0>{number = 4, name = (null)}
2018-05-17 15:28:06.990673+0800 MultiThread[14961:1367885] 2---<NSThread: 0x60400027ccc0>{number = 4, name = (null)}
添加依赖后，永远是op1先执行。
5. NSOperation优先级
NSOperation 提供了queuePriority（优先级）属性，queuePriority属性适用于同一操作队列中的操作，不适用于不同操作队列中的操作。默认情况下，所有新创建的操作对象优先级都是NSOperationQueuePriorityNormal。但是我们可以通过setQueuePriority:方法来改变当前操作在同一队列中的执行优先级。
// 优先级的取值
typedef NS_ENUM(NSInteger, NSOperationQueuePriority) {
NSOperationQueuePriorityVeryLow = -8L,
NSOperationQueuePriorityLow = -4L,
NSOperationQueuePriorityNormal = 0,
NSOperationQueuePriorityHigh = 4,
NSOperationQueuePriorityVeryHigh = 8
};
在没有依赖关系的操作之间，可以通过优先级来决定操作开始执行的顺序。
6. NSOperation，NSOperationQueue线程间的通信
- (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]); // 打印当前线程
}
}];
}];
}
2018-05-17 15:37:56.670333+0800 MultiThread[15086:1383288] 1---<NSThread: 0x604000470f40>{number = 3, name = (null)}
2018-05-17 15:37:58.672749+0800 MultiThread[15086:1383288] 1---<NSThread: 0x604000470f40>{number = 3, name = (null)}
2018-05-17 15:38:00.674389+0800 MultiThread[15086:1382902] 2---<NSThread: 0x60000006f000>{number = 1, name = main}
2018-05-17 15:38:02.675024+0800 MultiThread[15086:1382902] 2---<NSThread: 0x60000006f000>{number = 1, name = main}
线程中的通信，是先执行其他子线程的操作，然后回到主线程执行相关操作。
7.线程安全
线程同步安全问题，可以通过NSLock来实现，以之前GCD中有关smemaphore的卖票代码为例子，只需要在卖票操作之前加上[self.lock lock];在操作完成后解锁[self.lock unlock];即可。
- (void)saleTicketSafe {
while (1) {
// 加锁
[self.lock lock];
if (self.ticketSurplusCount > 0) {
//如果还有票，继续售卖
self.ticketSurplusCount--;
NSLog(@"%@", [NSString stringWithFormat:@"剩余票数:%d 窗口:%@", self.ticketSurplusCount, [NSThread currentThread]]);
[NSThread sleepForTimeInterval:0.2];
}
// 解锁
[self.lock unlock];
if (self.ticketSurplusCount <= 0) {
NSLog(@"所有火车票均已售完");
break;
}
}
}
8. 其他属性，方法
8.1 NSOperation属性和方法
1.取消操作方法
- (void)cancel; 可取消操作，实质是标记 isCancelled 状态。
2.判断操作状态方法
- (BOOL)isFinished; 判断操作是否已经结束。
- (BOOL)isCancelled; 判断操作是否已经标记为取消。
- (BOOL)isExecuting; 判断操作是否正在在运行。
- (BOOL)isReady; 判断操作是否处于准备就绪状态，这个值和操作的依赖关系相关。
3.操作同步
- (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; 在当前操作开始执行之前完成执行的所有操作对象数组。
8.2 NSOperationQueue属性和方法
1.取消/暂停/恢复操作
- (void)cancelAllOperations; 可以取消队列的所有操作。
- (BOOL)isSuspended; 判断队列是否处于暂停状态。 YES 为暂停状态，NO 为恢复状态。
- (void)setSuspended:(BOOL)b; 可设置操作的暂停和恢复，YES 代表暂停队列，NO 代表恢复队列。
2.操作同步
- (void)waitUntilAllOperationsAreFinished; 阻塞当前线程，直到队列中的操作全部执行完毕。
3.添加/获取操作
- (void)addOperationWithBlock:(void (^)(void))block; 向队列中添加一个 NSBlockOperation 类型操作对象。
- (void)addOperations:(NSArray *)ops waitUntilFinished:(BOOL)wait; 向队列中添加操作数组，wait 标志是否阻塞当前线程直到所有操作结束
- (NSArray *)operations; 当前在队列中的操作数组（某个操作执行结束后会自动从这个数组清除）。
- (NSUInteger)operationCount; 当前队列中的操作数。
4.获取队列
+ (id)currentQueue; 获取当前队列，如果当前线程不是在 NSOperationQueue 上运行则返回 nil。
+ (id)mainQueue; 获取主队列。
参考
iOS多线程：『NSOperation、NSOperationQueue』详尽总结
并发编程指南
NSOperation
并发编程：API 及挑战
