iOS多线程--NSOperation详解

2017-09-14 本文已影响104人 Claire_wu

1. NSOperation简介

在某些情况下，执行后台任务GCD不一定是最好的方式，还有一种技术叫做操作队列NSOperationQueue.NSOperation是苹果提供给我们的一套多线程解决方案。实际上NSOperation是基于GCD更高一层的封装，但是比GCD更简单易用、代码可读性也更高。相对于GCD，使用NSOperation和NSOperationQueue有以下好处：

取消操作。运行任务之前可以在operation对象上执行cancel操作标识此任务不需执行，如果是GCD，已经加入到队列的则无法取消了。
指定操作间的依赖关系。一个操作可以依赖于其他多个操作，比如某些操作必须在前置操作全部完成后才能开始。
KVO观察NSOperation对象的属性。NSOperation对象有非常多的属性都适合用KVO来监听，比如isCancelled和isFinished属性。比如想在某个任务状态变更时得到通知，键值观测将非常有用。
指定操作的优先级。GCD只有队列才有优先级，而不是针对每个操作块来说的。
重用NSOperation对象。系统内置了一些NSOperation的子类（比如NSBlockOperation），如果不想用这些固有的类，还可以自定义。这些类就是普通的OC对象，可以存储任何信息。

NSOperation需要配合NSOperationQueue来实现多线程。因为默认情况下，NSOperation单独使用时系统同步执行操作，并没有开辟新线程的能力，只有配合NSOperationQueue才能实现异步执行。因为NSOperation是基于GCD的，那么使用起来也和GCD差不多，其中，NSOperation相当于GCD中的任务，而NSOperationQueue则相当于GCD中的队列。NSOperation实现多线程的使用步骤分为三步：

创建任务：先将需要执行的操作封装到一个NSOperation对象中。
创建队列：创建NSOperationQueue对象。
将任务加入到队列中：然后将NSOperation对象添加到NSOperationQueue中。
之后呢，系统就会自动将NSOperationQueue中的NSOperation取出来，在新线程中执行操作。

2 NSOperation和NSOperationQueue的基本使用

2.1 创建任务

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

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

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

2.1.1 使用NSInvokeOpearion

- (IBAction)testInvokeOperation:(id)sender {
    // 1.创建NSInvocationOperation对象
    NSInvocationOperation *op = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(run) object:nil];
    
    // 2.调用start方法开始执行操作
    [op start];
}

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

输出结果：
2017-09-14 13:51:21.092 TestGCD[845:126221] ------testInvokeOperation:<NSThread: 0x17407abc0>{number = 1, name = main}
单独使用NSInvocationOperation的情况下，NSInvocationOperation在主线程执行操作，并没有开启新线程。

2.1.2 使用NSBlockOperation

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

输出结果：
2017-09-14 13:48:00.326 TestGCD[845:126221] ------testBlockOperation:<NSThread: 0x17407abc0>{number = 1, name = main}

单独使用NSBlockOperation的情况下，NSBlockOperation也是在主线程执行操作，并没有开启新线程。但是，NSBlockOperation还提供了一个方法addExecutionBlock:，通过addExecutionBlock:就可以为NSBlockOperation添加额外的操作，这些额外的操作就会在其他线程并发执行。

- (IBAction)testBlockOperation:(id)sender {
    NSBlockOperation *op = [NSBlockOperation blockOperationWithBlock:^{
        // 在主线程
        NSLog(@"------testBlockOperation:%@", [NSThread currentThread]);
    }];
    
    // 添加额外的任务(在子线程执行)
    [op addExecutionBlock:^{
        NSLog(@"2------%@", [NSThread currentThread]);
    }];
    [op addExecutionBlock:^{
        NSLog(@"3------%@", [NSThread currentThread]);
    }];
    [op addExecutionBlock:^{
        NSLog(@"4------%@", [NSThread currentThread]);
    }];
    
    [op start];
}

输出结果：
2017-09-14 14:01:39.915 TestGCD[862:128404] 2------<NSThread: 0x170073640>{number = 3, name = (null)}
2017-09-14 14:01:39.915 TestGCD[862:128291] ------testBlockOperation:<NSThread: 0x17006d900>{number = 1, name = main}
2017-09-14 14:01:39.919 TestGCD[862:128291] 4------<NSThread: 0x17006d900>{number = 1, name = main}
2017-09-14 14:01:39.919 TestGCD[862:128404] 3------<NSThread: 0x170073640>{number = 3, name = (null)}

可以看出，blockOperationWithBlock:方法中的操作是在主线程中执行的，而addExecutionBlock:方法中的操作是在其他线程中执行的。

2.1.3 使用自定义的NSOperation

先定义一个继承自NSOperation的子类，重写main方法

//  WYEOperation.h
#import <Foundation/Foundation.h>
@interface WYEOperation : NSOperation
@end

//  WYEOperation.m
#import "WYEOperation.h"
@implementation WYEOperation

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

- (IBAction)testWYEOperation:(id)sender {
    WYEOperation *op = [[WYEOperation alloc] init];
    [op start];
}

输出结果：
2017-09-14 14:27:51.905 TestGCD[885:131618] 1-----<NSThread: 0x17406dd00>{number = 1, name = main}
2017-09-14 14:27:51.908 TestGCD[885:131618] 1-----<NSThread: 0x17406dd00>{number = 1, name = main}

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

2.2 创建队列

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

主队列。凡是添加到主队列中的任务（NSOperation），都会放到主线程中执行。

NSOperationQueue *queue = [NSOperationQueue mainQueue];

其他队列。添加到这种队列中的任务（NSOperation），就会自动放到子线程中执行，同时包含了：串行、并发功能。

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

2.3 将任务加入到队列中

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

2.3.1 addOperation。需要先创建任务，再将创建好的任务加入到创建好的队列中去。

- (IBAction)testAddOperationQueue:(id)sender {
    // 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
{
    NSLog(@"------run:%@", [NSThread currentThread]);
}

输出结果：
2017-09-14 16:00:45.429 TestGCD[987:145817] 1-----<NSThread: 0x17007fc40>{number = 4, name = (null)}
2017-09-14 16:00:45.430 TestGCD[987:145806] ------run:<NSThread: 0x17007f280>{number = 3, name = (null)}
2017-09-14 16:00:45.433 TestGCD[987:145817] 1-----<NSThread: 0x17007fc40>{number = 4, name = (null)}

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

2.3.2 addOperationWithBlock。无需先创建任务，在block中添加任务，直接将任务block加入到队列中。

- (IBAction)testAddOperationBlock:(id)sender {
    // 1. 创建队列
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];
    
    // 2. 添加操作到队列中：addOperationWithBlock:
    [queue addOperationWithBlock:^{
        for (int i = 0; i < 2; ++i) {
            NSLog(@"-----%@", [NSThread currentThread]);
        }
    }];
}

输出结果：
2017-09-14 16:23:30.031 TestGCD[1023:149967] -----<NSThread: 0x17406dd00>{number = 3, name = (null)}
2017-09-14 16:23:30.033 TestGCD[1023:149967] -----<NSThread: 0x17406dd00>{number = 3, name = (null)}

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

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

之前说过，NSOperationQueue创建的其他队列同时具有串行、并发功能，上边我们演示了并发功能，那么他的串行功能是如何实现的？这里有个关键参数maxConcurrentOperationCount，叫做最大并发数。

maxConcurrentOperationCount默认情况下为-1，表示不进行限制，默认为并发执行。
当maxConcurrentOperationCount为1时，进行串行执行。
当maxConcurrentOperationCount大于1时，进行并发执行，当然这个值不应超过系统限制，即使自己设置一个很大的值，系统也会自动调整。
可以看如下示例：

- (IBAction)testMaxConcurrent:(id)sender {
    // 创建队列
    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时，任务是按顺序串行执行的。当最大并发数为2时，任务是并发执行的。而且开启线程数量是由系统决定的，不需要我们来管理。

4 操作依赖

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

- (IBAction)testDependency:(id)sender {
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];
    
    NSBlockOperation *op1 = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"1-----%@", [NSThread  currentThread]);
    }];
    NSBlockOperation *op2 = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"2-----%@", [NSThread  currentThread]);
    }];
    
    [op1 addDependency:op2];    // 让op2 依赖于 op1，则先执行op1，在执行op2
    
    [queue addOperation:op1];
    [queue addOperation:op2];
}

输出结果：
2017-09-14 16:42:40.910 TestGCD[1065:153434] 2-----<NSThread: 0x17026cc40>{number = 3, name = (null)}
2017-09-14 16:42:40.914 TestGCD[1065:153434] 1-----<NSThread: 0x17026cc40>{number = 3, name = (null)}

无论运行几次，都是2在1之前运行。

5 其他方法

- (void)cancel;    //NSOperation提供的方法，可取消单个操作
- (void)cancelAllOperations;     //NSOperationQueue提供的方法，可以取消队列的所有操作
- (void)setSuspended:(BOOL)b;     //可设置任务的暂停和恢复，YES代表暂停队列，NO代表恢复队列
- (BOOL)isSuspended;     //判断暂停状态

注意：这里的暂停和取消并不代表可以将当前的操作立即取消，而是当当前的操作执行完毕之后不再执行新的操作。
暂停和取消的区别就在于：暂停操作之后还可以恢复操作，继续向下执行；而取消操作之后，所有的操作就清空了，无法再接着执行剩下的操作。

6 参考资料

iOS多线程--彻底学会多线程之『NSOperation』