iOS多线程详解(四)--- NSOperation

1、简介

NSOperation是苹果提供给我们的一套多线程解决方案。实际上NSOperation是基于GCD更高一层的封装,但是比GCD更简单易用、代码可读性也更高。
NSOperation需要配合NSOperationQueue来实现多线程。因为默认情况下,NSOperation单独使用时系统同步执行操作,并没有开辟新线程的能力,只有配合NSOperationQueue才能实现异步执行。
因为NSOperation是基于GCD的,那么使用起来也和GCD差不多,其中,NSOperation相当于GCD中的任务,而NSOperationQueue则相当于GCD中的队列。NSOperation实现多线程的使用步骤分为三步:

  1. 创建任务:先将需要执行的操作封装到一个NSOperation对象中。
  2. 创建队列:创建NSOperationQueue对象。
  3. 将任务加入到队列中:然后将NSOperation对象添加到NSOperationQueue中。

之后呢,系统就会自动将NSOperationQueue中的NSOperation取出来,在新线程中执行操作。
下面我们来学习下NSOperation和NSOperationQueue的基本使用。

2、NSOperation和NSOperationQueue的基本使用

1、创建任务

NSOperation是个抽象类,并不能封装任务。我们只有使用它的子类来封装任务。我们有三种方式来封装任务。

  1. 使用子类NSInvocationOperation
  2. 使用子类NSBlockOperation
  3. 定义继承自NSOperation的子类,通过实现内部相应的方法来封装任务。

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

1、使用子类NSInvocationOperation

// 1.创建NSInvocationOperation对象
NSInvocationOperation *op = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(run) object:nil];

// 2.调用start方法开始执行操作
[op start];

- (void)run
{
    NSLog(@"------%@", [NSThread currentThread]);
}

输出结果:
2017-11-20 10:41:16.521032+0800 test[5023:190051] ------<NSThread: 0x6040000662c0>{number = 1, name = main}

从中可以看到,在没有使用NSOperationQueue、单独使用NSInvocationOperation的情况下,NSInvocationOperation在主线程执行操作,并没有开启新线程。

下边再来看看NSBlockOperation。

2、使用子类NSBlockOperation

NSBlockOperation *op = [NSBlockOperation blockOperationWithBlock:^{
    // 在主线程
    NSLog(@"------%@", [NSThread currentThread]);
}];

[op start];

输出结果:
2017-11-20 10:43:29.704281+0800 test[5145:202303] ------<NSThread: 0x60400006bac0>{number = 1, name = main}

我们同样可以看到,在没有使用NSOperationQueue、单独使用NSBlockOperation的情况下,NSBlockOperation也是在主线程执行操作,并没有开启新线程。

但是,NSBlockOperation还提供了一个方法addExecutionBlock:,通过addExecutionBlock:就可以为NSBlockOperation添加额外的操作,这些操作就会并发执行。

- (void)blockOperation
{
    NSBlockOperation *op = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"1------%@", [NSThread currentThread]);
    }];    

    // 添加额外的任务
    [op addExecutionBlock:^{
        NSLog(@"2------%@", [NSThread currentThread]);
    }];
    [op addExecutionBlock:^{
        NSLog(@"3------%@", [NSThread currentThread]);
    }];
    [op addExecutionBlock:^{
        NSLog(@"4------%@", [NSThread currentThread]);
    }];

    [op start];
}

输出结果:
2017-11-20 10:46:12.639798+0800 test[5279:215979] 1------<NSThread: 0x6000004624c0>{number = 3, name = (null)}
2017-11-20 10:46:12.639797+0800 test[5279:215842] 4------<NSThread: 0x60400007ac80>{number = 1, name = main}
2017-11-20 10:46:12.639797+0800 test[5279:215977] 2------<NSThread: 0x600000462500>{number = 5, name = (null)}
2017-11-20 10:46:12.639829+0800 test[5279:215976] 3------<NSThread: 0x604000464940>{number = 4, name = (null)}

可以看出,blockOperationWithBlock:方法和addExecutionBlock:方法所添加的操作是在多条线程中执行的。

3、定义继承自NSOperation的子类

先定义一个继承自NSOperation的子类,重写main方法
YSCOperation.h

#import <Foundation/Foundation.h>

@interface YSCOperation : NSOperation

@end

YSCOperation.m

#import "YSCOperation.h"

@implementation YSCOperation
/**
 * 需要执行的任务
 */

- (void)main
{
    for (int i = 0; i < 2; ++i) {
        NSLog(@"1-----%@",[NSThread currentThread]);
    }    
}

@end

然后使用的时候导入头文件YSCOperation.h。

// 创建YSCOperation
YSCOperation *op1 = [[YSCOperation alloc] init];

[op1 start];

输出结果:
2017-11-20 10:56:40.268238+0800 test[5904:271380] 1-----<NSThread: 0x604000069300>{number = 1, name = main}
2017-11-20 10:56:40.268409+0800 test[5904:271380] 1-----<NSThread: 0x604000069300>{number = 1, name = main}

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

下边我们简单讲讲NSOperationQueue的创建。

2、创建队列

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

  • 主队列
    凡是添加到主队列中的任务(NSOperation),都会放到主线程中执行
NSOperationQueue *queue = [NSOperationQueue mainQueue];
  • 其他队列(非主队列)
    添加到这种队列中的任务(NSOperation),就会自动放到子线程中执行
    同时包含了:串行、并发功能
NSOperationQueue *queue = [[NSOperationQueue alloc] init];

3、将任务加入到队列中

前边说了,NSOperation需要配合NSOperationQueue来实现多线程。
那么我们需要将创建好的任务加入到队列中去。总共有两种方法

  1. - (void)addOperation:(NSOperation *)op;
    需要先创建任务,再将创建好的任务加入到创建好的队列中去
- (void)addOperationToQueue
{
    // 1.创建队列
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];

    // 2. 创建操作  
    // 创建NSInvocationOperation    
    NSInvocationOperation *op1 = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(run) object:nil];    
    // 创建NSBlockOperation    
    NSBlockOperation *op2 = [NSBlockOperation blockOperationWithBlock:^{
        for (int i = 0; i < 2; ++i) {
            NSLog(@"1-----%@", [NSThread currentThread]);
        }
    }];

    // 3. 添加操作到队列中:addOperation:   
    [queue addOperation:op1]; // [op1 start]    
    [queue addOperation:op2]; // [op2 start]
}

- (void)run
{
    for (int i = 0; i < 2; ++i) {
        NSLog(@"2-----%@", [NSThread currentThread]);
    }
}

输出结果:
2017-11-20 11:06:47.458543+0800 test[6376:322141] 1-----<NSThread: 0x60400046c180>{number = 3, name = (null)}
2017-11-20 11:06:47.458580+0800 test[6376:322142] 2-----<NSThread: 0x60400046c200>{number = 4, name = (null)}
2017-11-20 11:06:47.458878+0800 test[6376:322142] 2-----<NSThread: 0x60400046c200>{number = 4, name = (null)}
2017-11-20 11:06:47.458885+0800 test[6376:322141] 1-----<NSThread: 0x60400046c180>{number = 3, name = (null)}

可以看出:NSInvocationOperation和NSOperationQueue结合后能够开启新线程,进行并发执行。NSBlockOperation和NSOperationQueue也能够开启新线程,进行并发执行。

  1. - (void)addOperationWithBlock:(void (^)(void))block;
    无需先创建任务,在block中添加任务,直接将任务block加入到队列中。
- (void)addOperationWithBlockToQueue
{
    // 1. 创建队列
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];

    // 2. 添加操作到队列中:addOperationWithBlock:
    [queue addOperationWithBlock:^{
        for (int i = 0; i < 2; ++i) {
            NSLog(@"-----%@", [NSThread currentThread]);
        }
    }];
}

输出结果:
2017-11-20 11:17:46.614125+0800 test[6880:376408] -----<NSThread: 0x60000026e500>{number = 3, name = (null)}
2017-11-20 11:17:46.614348+0800 test[6880:376408] -----<NSThread: 0x60000026e500>{number = 3, name = (null)}

可以看出addOperationWithBlock:和NSOperationQueue能够开启新线程,进行并发执行。

3、控制串行执行和并行执行的关键

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

这里有个关键参数maxConcurrentOperationCount,叫做最大并发数。

  • 最大并发数:maxConcurrentOperationCount
  1. maxConcurrentOperationCount默认情况下为-1,表示不进行限制,默认为并发执行。
  2. maxConcurrentOperationCount为1时,进行串行执行。
  3. maxConcurrentOperationCount大于1时,进行并发执行,当然这个值不应超过系统限制,即使自己设置一个很大的值,系统也会自动调整。
- (void)opetationQueue
{
    // 创建队列
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];

    // 设置最大并发操作数
    //    queue.maxConcurrentOperationCount = 2;
    queue.maxConcurrentOperationCount = 1; // 就变成了串行队列

    // 添加操作
    [queue addOperationWithBlock:^{
        NSLog(@"1-----%@", [NSThread currentThread]);
        [NSThread sleepForTimeInterval:0.01];
    }];
    [queue addOperationWithBlock:^{
        NSLog(@"2-----%@", [NSThread currentThread]);
        [NSThread sleepForTimeInterval:0.01];
    }];
    [queue addOperationWithBlock:^{
        NSLog(@"3-----%@", [NSThread currentThread]);
        [NSThread sleepForTimeInterval:0.01];
    }];
    [queue addOperationWithBlock:^{
        NSLog(@"4-----%@", [NSThread currentThread]);
        [NSThread sleepForTimeInterval:0.01];
    }];
    [queue addOperationWithBlock:^{
        NSLog(@"5-----%@", [NSThread currentThread]);
        [NSThread sleepForTimeInterval:0.01];
    }];

    [queue addOperationWithBlock:^{
        NSLog(@"6-----%@", [NSThread currentThread]);
        [NSThread sleepForTimeInterval:0.01];
    }];
}

最大并发数为1输出结果:
2017-11-20 11:23:03.110467+0800 test[7122:398971] 1-----<NSThread: 0x600000464c00>{number = 3, name = (null)}
2017-11-20 11:23:03.120945+0800 test[7122:398973] 2-----<NSThread: 0x6040004614c0>{number = 4, name = (null)}
2017-11-20 11:23:03.131556+0800 test[7122:398971] 3-----<NSThread: 0x600000464c00>{number = 3, name = (null)}
2017-11-20 11:23:03.144559+0800 test[7122:398973] 4-----<NSThread: 0x6040004614c0>{number = 4, name = (null)}
2017-11-20 11:23:03.155188+0800 test[7122:398971] 5-----<NSThread: 0x600000464c00>{number = 3, name = (null)}
2017-11-20 11:23:03.165532+0800 test[7122:398973] 6-----<NSThread: 0x6040004614c0>{number = 4, name = (null)}

最大并发数为2输出结果:
2017-11-20 11:23:55.953623+0800 test[7179:404017] 2-----<NSThread: 0x60000027a940>{number = 4, name = (null)}
2017-11-20 11:23:55.953644+0800 test[7179:404018] 1-----<NSThread: 0x60000027aa00>{number = 3, name = (null)}
2017-11-20 11:23:55.964036+0800 test[7179:404015] 3-----<NSThread: 0x60400007fc80>{number = 5, name = (null)}
2017-11-20 11:23:55.964046+0800 test[7179:404016] 4-----<NSThread: 0x600000277240>{number = 6, name = (null)}
2017-11-20 11:23:55.974361+0800 test[7179:404018] 5-----<NSThread: 0x60000027aa00>{number = 3, name = (null)}
2017-11-20 11:23:55.974361+0800 test[7179:404017] 6-----<NSThread: 0x60000027a940>{number = 4, name = (null)}

可以看出:当最大并发数为1时,任务是按顺序串行执行的。当最大并发数为2时,任务是并发执行的。而且开启线程数量是由系统决定的,不需要我们来管理。这样看来,是不是比GCD还要简单了许多?

4、操作依赖

NSOperation和NSOperationQueue最吸引人的地方是它能添加操作之间的依赖关系。比如说有A、B两个操作,其中A执行完操作,B才能执行操作,那么就需要让B依赖于A。具体如下:

- (void)addDependency
{
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];

    NSBlockOperation *op1 = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"1-----%@", [NSThread  currentThread]);
    }];
    NSBlockOperation *op2 = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"2-----%@", [NSThread  currentThread]);
    }];

    [op2 addDependency:op1];    // 让op2 依赖于 op1,则先执行op1,在执行op2

    [queue addOperation:op1];
    [queue addOperation:op2];
}

输出结果:
2017-11-20 11:27:36.191658+0800 test[7363:423406] 1-----<NSThread: 0x600000261740>{number = 3, name = (null)}
2017-11-20 11:27:36.192122+0800 test[7363:423409] 2-----<NSThread: 0x600000261a80>{number = 4, name = (null)}

可以看到,无论运行几次,其结果都是op1先执行,op2后执行。

5、一些其他方法

  • -(void)cancel; NSOperation提供的方法,可取消单个操作
  • -(void)cancelAllOperations; NSOperationQueue提供的方法,可以取消队列的所有操作
  • -(void)setSuspended:(BOOL)b; 可设置任务的暂停和恢复,YES代表暂停队列,NO代表恢复队列
  • -(BOOL)isSuspended; 判断暂停状态
  • 注意:
    1.这里的暂停和取消并不代表可以将当前的操作立即取消,而是当当前的操作执行完毕之后不再执行新的操作。
    2.暂停和取消的区别就在于:暂停操作之后还可以恢复操作,继续向下执行;而取消操作之后,所有的操作就清空了,无法再接着执行剩下的操作。

6、NSOperation优先级

GCD中,任务(block)是没有优先级的,而队列具有优先级。和GCD相反,我们一般考虑 NSOperation 的优先级。
NSOperation 有一个NSOperationQueuePriority 枚举类型的属性 queuePriority。

public enum NSOperationQueuePriority : Int {  
    case VeryLow
    case Low
    case Normal
    case High
    case VeryHigh
}

需要注意的是,NSOperationQueue 也不能完全保证优先级高的任务一定先执行。
queuePriority默认值是NSOperationQueuePriorityNormal。根据实际需要我们可以通过调用queuePriority的setter方法修改某个操作的优先级。

NSBlockOperation *blkop1 = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"执行blkop1");
    }];

    NSBlockOperation *blkop2 = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"执行blkop2");
    }];

    // 设置操作优先级
    blkop1.queuePriority = NSOperationQueuePriorityLow;
    blkop2.queuePriority = NSOperationQueuePriorityVeryHigh;

    NSLog(@"blkop1 == %@",blkop1);
    NSLog(@"blkop2 == %@",blkop2);

    NSOperationQueue *queue = [[NSOperationQueue alloc] init];
    // 操作添加到队列
    [queue addOperation:blkop1];
    [queue addOperation:blkop2];

    NSLog(@"%@",[queue operations]);
    for (NSOperation *op in [queue operations]) {
        NSLog(@"op == %@",op);
    }

输出结果:
2017-02-12 19:36:01.149 NSOperation[1712:177976] blkop1 == <NSBlockOperation: 0x608000044440>
2017-02-12 19:36:01.150 NSOperation[1712:177976] blkop2 == <NSBlockOperation: 0x6080000444d0>
2017-02-12 19:36:01.150 NSOperation[1712:177976] (
"<NSBlockOperation: 0x608000044440>",
"<NSBlockOperation: 0x6080000444d0>"
)
2017-02-12 19:36:01.150 NSOperation[1712:177976] op == <NSBlockOperation: 0x608000044440>
2017-02-12 19:36:01.150 NSOperation[1712:177976] op == <NSBlockOperation: 0x6080000444d0>
2017-02-12 19:36:01.150 NSOperation[1712:178020] 执行blkop1
2017-02-12 19:36:01.151 NSOperation[1712:178021] 执行blkop2

解析:

  1. 上面创建了两个blockOperation并且分别设置了优先级。显然blkop1的优先级低于blkop2的优先级。然后调用了队列的addOperation:方法使操作入队。最后输出结果证明,操作在对列中的顺序取决于addOperation:方法而不是优先级。
  2. 虽然blkop2优先级高于blkop1,但是bloop1却先于blkop2执行完成。所以,优先级高的操作不一定先执行完成。
  3. blkop2优先级高于blkop1,则代表blkop2先被执行,但是由于多线程的存在,blkop1可能会与blkop2并行执行。

注意:
(1)优先级只能应用于相同queue中的operations。
(2)操作的优先级高低不等于操作在队列中排列的顺序。换句话说,优先级高的操作不代表一定排在队列的前面。后入队的操作有可能因为优先级高而先被执行。PS:操作在队列中的顺序取决于队列的addOperation:方法。
(3)优先级高只代表先被执行。不代表操作先被执行完成。执行完成的早晚还取决于操作耗时长短。
(4)优先级不能替代依赖,优先级也绝不等于依赖。优先级只是对已经准备好的操作确定其执行顺序。
(5)操作的执行优先满足依赖关系,然后再满足优先级。即先根据依赖执行操作,然后再从所有准备好的操作中取出优先级最高的那一个执行。

7、:waitUntilAllOperationsAreFinished

为了最佳的性能,你应该设计你的应用尽可能地异步操作,让应用在Operation正在执行时可以去处理其它事情。如果需要在当前线程中处理operation完成后的结果,可以使用NSOperation的waitUntilFinished方法阻塞当前线程,等待operation完成。通常我们应该避免编写这样的代码,阻塞当前线程可能是一种简便的解决方案,但是它引入了更多的串行代码,限制了整个应用的并发性,同时也降低了用户体验。绝对不要在应用主线程中等待一个Operation,只能在第二或次要线程中等待。阻塞主线程将导致应用无法响应用户事件,应用也将表现为无响应。

// 会阻塞当前线程,等到某个operation执行完毕  
    [operation waitUntilFinished];

除了等待单个Operation完成,你也可以同时等待一个queue中的所有操作,使用NSOperationQueue的waitUntilAllOperationsAreFinished方法。注意:在等待一个 queue时,应用的其它线程仍然可以往queue中添加Operation,因此可能会加长线程的等待时间。

// 阻塞当前线程,等待queue的所有操作执行完毕  
    [queue waitUntilAllOperationsAreFinished];

注意:waitUntilAllOperationsAreFinished一定要在操作队列添加了操作后再设置。即,先向operation queue中添加operation,再调用[operationQueue waitUntilAllOperationsAreFinished]。

NSBlockOperation *blkop = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"执行操作 %@",[NSThread currentThread]);
    }];

    NSOperationQueue *queue = [[NSOperationQueue alloc] init];

    [queue addOperation:blkop];
    // waitUntilAllOperationsAreFinished就像GCD的barrier一样起到隔离作用
    // waitUntilAllOperationsAreFinished必须要在操作添加到队列后设置
    // waitUntilAllOperationsAreFinished必须要在NSLog(@"finish");之前设置waitUntilAllOperationsAreFinished
    [queue waitUntilAllOperationsAreFinished];

    NSLog(@"finish");

8、有了GCD,为什么还有要用NSOperationQueue

  • GCD是底层的C语言构成的API,而NSOperationQueue以及相关对象是基于GCD的Objective-C对象的封装,作为一个对象,NSOperationQueue为我们提供了更多的选择

  • NSOperationQueue任务可以很方便的取消(也只能取消未执行的任务),而GCD没法停止已经加入队列的任务(其实是有的,但需要许多复杂的代码)

  • 不像GCD那样的是按FIFO顺序来执行的,NSOperation能够方便地通过依赖关系设置操作执行顺序,可以控制任务在特定的任务执行完后才执行;而GCD要实现这个功能的话,就需要通过barrier或者group来控制执行顺序,如果依赖关系复杂的话,代码逻辑就非常复杂了

  • NSOperation支持KVO(Key-Value Observing),可以方便的监听任务的状态(完成、执行中、取消等等状态)

  • NSOperation可以设置同一个队列中任务的优先级,能够使同一个并行队列中的任务区分先后地执行,而在GCD中,我们只能区分不同任务队列的优先级,如果要区分block任务的优先级,也需要大量的复杂代码

  • 还可以通过自定义NSOperation,封装任务逻辑,提高整个代码的复用度

  • 综合比较其各自使用范围如下

  1. GCD更接近底层,而NSOperationQueue则更高级抽象,所以GCD在追求性能的底层操作来说,是速度最快的。

  2. 从异步操作之间的事务性,顺序行,依赖关系。GCD需要自己写更多的代码来实现,而NSOperationQueue已经内建了这些支持

  3. 如果异步操作的过程需要更多的被交互和UI呈现出来,NSOperationQueue会是一个更好的选择。底层代码中,任务之间不太互相依赖,而需要更高的并发能力,GCD则更有优势

9、小结

虽然在iOS开发中,多线程方法大部分使用的还是GCD,但是对于某些特殊需求,如取消任务、设置任务执行顺序、任务状态监听、复杂任务封装等还是推荐使用NSOperationQueue,实现起来会方便很多。
至此,iOS中常用的多线程方式介绍完毕。

相关系列文章

iOS多线程详解(一)--- 多线程基础
iOS多线程详解(二)--- pthread&NSThread
iOS多线程详解(三)--- GCD
iOS多线程详解(四)--- NSOperation
iOS多线程详解(五)--- 线程安全(锁的创建)
iOS多线程详解(六)--- 线程安全(Property)

参考文献

本文主要参考了下面的链接,特向作者表示感谢
http://www.jianshu.com/p/52fe1b85c404
http://www.jianshu.com/p/4b1d77054b35
http://www.jianshu.com/p/e6cd25f6da91

推荐阅读更多精彩内容