iOS多线程系列之四：NSOperation以及多线程技术比较
本文导读：NSOperation作为苹果推荐的重要并发技术之一，在开发当中也较为常用。本文将详细介绍NSOperation两个子类以及NSOperationQueue的使用。而笔者前面的文章[iOS多线程基础][1]已经详细介绍了简单的多线程NSThread和基于C语言的功能强大的GCD，有需要的同学可以去看一下。既然有三种多线程技术，那它们又有什么区别呢？使用场景怎样呢？笔者将在本文末尾为大家一一解答
NSOperation是苹果推荐使用的并发技术，它提供了一些用GCD不是很好实现的功能。NSOperation是基于GCD的面向对象的使用OC语言的封装。相比GCD，NSOperation的使用更加简单。NSOperation是一个抽象类，也就是说它并不能直接使用，而是应该使用它的子类。使用它的子类的方法有三种，使用苹果为我们提供的两个子类 NSInvocationOperation，NSBlockOperation和自定义继承自NSOperation的子类。
NSOperation的使用常常是配合NSOperationQueue来进行的。只要是使用NSOperation的子类创建的实例就能添加到NSOperationQueue操作队列之中，一旦添加到队列，操作就会自动异步执行（注意是异步）。如果没有添加到队列，而是使用start方法，则会在当前线程执行。
我们知道，线程间的通信主要是主线程与分线程之间进行的。主线程到分线程，NSOperation子类也有相应带参数的方法；而分线程到主线程，比如更新UI，它也有很方便的获取主队列（被添加到主队列的操作默认会在主线程执行）的方法：[NSOperationQueue mainQueue]。
##一、NSInvocationOperation
###1.单个NSInvocationOperation
<1>直接创建一个NSInvocationOperation的对象，然后调用start方法会直接在主线程执行
//1.创建
NSOperation *op = [[NSInvocationOperation alloc]initWithTarget:self
selector:@selector(downloadImage:) object:@"Invocation"];
//2.start方法，直接在当前线程执行
[op start];
#pragma mark - 调用的耗时操作,后面调用的耗时操作都是这个
- (void)downloadImage:(id)obj{
NSLog(@"%@-----%@",[NSThread currentThread],obj);
}
输出 [1151:50868] {number = 1, name = main}-----Invocation
<2>添加到NSOperationQueue
//1.创建
NSOperation *op = [[NSInvocationOperation alloc]initWithTarget:self
selector:@selector(downloadImage:) object:@"Invocation"];
//2.放到队列里面去
NSOperationQueue *q = [[NSOperationQueue alloc]init];
//只要把操作放到队列，会自动异步执行调度方法
[q addOperation:op];
输出：[1192:55469] {number = 3, name = (null)}-----Invocation
在number为3，name为空的子线程执行
2.多个NSInvocationOperation
//队列，GCD里面的并发队列使用最多，所以NSOperation技术直接把GCD里面的并发队列封装起来
//NSOperationQueue本质就是GCD里面的并发队列
//操作就是GCD里面异步执行的任务
NSOperationQueue *q = [[NSOperationQueue alloc]init];
//把多个操作放到队列里面
for (int i = 0; i < 100; i++) {
NSOperation *op = [[NSInvocationOperation alloc]initWithTarget:self
selector:@selector(downloadImage:) object:[NSString stringWithFormat:@"Invocation%d",i]];
[q addOperation:op];
}
输出：
**[1222:58476] {number = 7, name = (null)}-----Invocation5
**[1222:58478] {number = 9, name = (null)}-----Invocation7
**[1222:58307] {number = 3, name = (null)}-----Invocation1
**[1222:58477] {number = 8, name = (null)}-----Invocation6
**[1222:58481] {number = 12, name = (null)}-----Invocation10
**[1222:58475] {number = 6, name = (null)}-----Invocation4
**[1222:58480] {number = 11, name = (null)}-----Invocation9
**[1222:58306] {number = 4, name = (null)}-----Invocation3
··· ···
线程名与输出均没有规律，很明显就是并发队列。
##二、NSBlockOperation
NSBlockOperation的用法与NSInvocationOperation相同，只是创建的方式不同，它不需要去调用方法，而是直接使用代码块,显得更方便。这也使得NSBlockOperation比NSInvocationOperation更加流行
//跟GCD中的并发队列一样
NSOperationQueue *q = [[NSOperationQueue alloc]init];
//跟GCD中的主队列一样
// NSOperationQueue *q = [NSOperationQueue mainQueue];
//把多个操作放到队列里面
for (int i = 0; i < 100; i++) {
NSBlockOperation *op = [NSBlockOperation blockOperationWithBlock:^{
NSLog(@"%@------%d",[NSThread currentThread],i);
}];
//把Block操作放到队列
[q addOperation:op];
}
NSLog(@"完成");
并发队列输出结果：
**[1378:72440] {number = 6, name = (null)}------5**
**[1378:72442] {number = 5, name = (null)}------7**
**[1378:72441] {number = 7, name = (null)}------6**
**[1378:72325] {number = 9, name = (null)}------2**
**[1378:72320] {number = 4, name = (null)}------3**
**[1378:72313] {number = 2, name = (null)}------1**
**[1378:72276] 完成
**[1378:72444] {number = 11, name = (null)}------9**
**[1378:72326] {number = 3, name = (null)}------0**
**[1378:72440] {number = 6, name = (null)}------12**
... ...
主队列输出结果：
**[1417:76086] 完成
**[1417:76086] {number = 1, name = main}------0**
**[1417:76086] {number = 1, name = main}------1**
**[1417:76086] {number = 1, name = main}------2**
**[1417:76086] {number = 1, name = main}------3**
**[1417:76086] {number = 1, name = main}------4**
**[1417:76086] {number = 1, name = main}------5**
**[1417:76086] {number = 1, name = main}------6**
**[1417:76086] {number = 1, name = main}------7**
... ...
事实上NSBlockOperation有更简单的使用方法
NSOperationQueue *q = [[NSOperationQueue alloc]init];
for (int i = 0; i < 10; i++) {
[q addOperationWithBlock:^{
NSLog(@"%@------%d",[NSThread currentThread],i);
}];
}
##三、线程间通信
主线程到子线程传对象，前面的例子里面已经有了，不再缀述。下面的例子就是回到主线程更新UI。
p.p1 {margin: 0.0px 0.0px 0.0px 0.0px; font: 14.0px Menlo; c
NSOperationQueue *q = [[NSOperationQueue alloc]init];
[q addOperationWithBlock:^{
NSLog(@"耗时操作--%@",[NSThread currentThread]);
[[NSOperationQueue mainQueue] addOperationWithBlock:^{
NSLog(@"更新UI-----%@",[NSThread currentThread]);
}];
}];
##四、NSOperationQueue的一些高级操作
NSOperationQueue支持的高级操作有：队列的挂起，队列的取消，添加操作的依赖关系和设置最大并发数
<1>最大并发数
@property (nonatomic,strong)NSOperationQueue *opQueue;
//重写getter方法实现懒加载
- (NSOperationQueue*)opQueue{
if (_opQueue == nil) {
_opQueue = [[NSOperationQueue alloc]init];
}
return _opQueue;
}
#pragma mark - 高级操作:最大并发数
//设置最大的并发数量（并非线程的数量）
self.opQueue.maxConcurrentOperationCount = 2;
//把多个操作放到队列里面
for (int i = 0; i < 10; i++) {
NSBlockOperation *op = [NSBlockOperation blockOperationWithBlock:^{
[NSThread sleepForTimeInterval:3.0];
NSLog(@"%@------%d",[NSThread currentThread],i);
}];
//把Block操作放到队列
[self.opQueue addOperation:op];
}
<2>线程的挂起
#pragma mark - 高级操作：线程的挂起
//暂停继续(对队列的暂停和继续)，挂起的是队列，不会影响已经在执行的操作
- (IBAction)pause:(UIButton *)sender {
//判断操作的数量，当前队列里面是不是有操作？
if (self.opQueue.operationCount == 0) {
NSLog(@"当前队列没有操作");
return;
}
self.opQueue.suspended = !self.opQueue.isSuspended;
if (self.opQueue.suspended) {
NSLog(@"暂停");
}else{
NSLog(@"继续");
}
}
<3>取消队列里的所有操作
#pragma mark - 高级操作：取消队列里的所有操作
- (IBAction)cancelAll:(UIButton *)sender {
//只能取消所有队列的里面的操作，正在执行的无法取消
//取消操作并不会影响队列的挂起状态
[self.opQueue cancelAllOperations];
NSLog(@"取消队列里所有的操作");
//取消队列的挂起状态
//（只要是取消了队列的操作，我们就把队列处于不挂起状态,以便于后续的开始）
self.opQueue.suspended = NO;
}
<4>依赖关系
/*
* 例子
*
* 1.下载一个小说压缩包
* 2.解压缩，删除压缩包
* 3.更新UI
*/
NSBlockOperation *op1 = [NSBlockOperation blockOperationWithBlock:^{
NSLog(@"1.下载一个小说压缩包,%@",[NSThread currentThread]);
}];
NSBlockOperation *op2 = [NSBlockOperation blockOperationWithBlock:^{
NSLog(@"2.解压缩，删除压缩包,%@",[NSThread currentThread]);
}];
NSBlockOperation *op3 = [NSBlockOperation blockOperationWithBlock:^{
NSLog(@"3.更新UI,%@",[NSThread currentThread]);
}];
//指定任务之间的依赖关系 --依赖关系可以跨队列(可以再子线程下载，在主线程更新UI)
[op2 addDependency:op1];
[op3 addDependency:op2];
// [op1 addDependency:op3]; 一定不能出现循环依赖
//waitUntilFinished 类似GCD中的调度组的通知
//NO不等待，直接执行输出come here
//YES等待任务执行完再执行输出come here
[self.opQueue addOperations:@[op1,op2] waitUntilFinished:YES];
//在主线程更新UI
[[NSOperationQueue mainQueue] addOperation:op3];
[op3 addDependency:op2];
NSLog(@"come here");
还有一个NSOperationQueuePriority，队列优先级的概念，因为用的极少，所以这里不做介绍，确实有需要的同学可以自己百度或者查看Documentation and API Reference。
##五、三种多线程技术
<1>NSThread
- 优点：NSThread 比其他两个轻量级，使用简单
- 缺点：需要自己管理线程的生命周期、线程同步、加锁、睡眠以及唤醒等。线程同步对数据的加锁会有一定的系统开销
<2>GCD
GCD 是iOS 4.0以后才出现的并发技术
- 使用方式：将任务添加到队列（串行/并行（全局）），指定执行任务的方法，（同步（阻塞）/异步 ）
- 拿到主队列：dispatch_get_main_queu()
- NSOperation无法做到的：1.一次性执行，2.延迟执行，3.调度组（op实现要复杂的多 ）
<3>NSOperation
NSOperation iOS2.0的时候就出现了（当时不好用，后来苹果对其进行改造）
- 使用方式：将操作（异步执行）添加到队列（并发/全局）
- 拿到主队列：[NSOperationQueue mainQueue] 主队列，任务添加到主队列就会在主线程执行
- 提供了GCD不好实现的：1.最大并发数，2.暂停和继续，3.取消所有任务，4.依赖关系
GCD是比较底层的封装，我们知道较低层的代码一般性能都是比较高的，相对于NSOperationQueue。所以追求性能，而功能够用的话就可以考虑使用GCD。如果异步操作的过程需要更多的用户交互和被UI显示出来，NSOperationQueue会是一个好选择。如果任务之间没有什么依赖关系，而是需要更高的并发能力，GCD则更有优势。
高德纳的教诲：“在大概97%的时间里，我们应该忘记微小的性能提升。过早优化是万恶之源。”只有Instruments显示有真正的性能提升时才有必要用低级的GCD。
参考文章：
[1]:http://www.jianshu.com/users/59cf63472310/latest_articles
[2] http://www.jianshu.com/p/af3c666685ba
[3]http://www.jianshu.com/p/8cc9b347bba7
[4]https://www.cnblogs.com/beckwang0912/p/7136862.html