[iOS] 多线程之NSOperation

1. 基础知识

NSOperation、NSOperationQueue 是基于 GCD 更高一层的封装，完全面向对象。但是比 GCD 更简单易用、代码可读性也更高。

1.1 NSOperation

指代的是操作，是一个抽象类。使用必须子类化，比如使用 NSInvocationOperation 和 NSBlockOperation，或者自定义子类。它只执行一次任务，不能用于再次执行它。
如果一个操作仍然依赖于尚未完成的其他操作，则认为该操作尚未准备好执行，也就是没有变成ready状态。

1.2 操作队列（Operation Queues）

这里的队列指操作队列，即用来存放操作的队列。不同于 GCD 中的调度队列 FIFO（先进先出）的原则。NSOperationQueue对于添加到队列中的操作，首先进入准备就绪的状态（就绪状态取决于操作之间的依赖关系），然后进入就绪状态的操作的开始执行顺序（非结束执行顺序）由操作之间相对的优先级决定（优先级是操作对象自身的属性）。

操作队列通过设置最大并发操作数（maxConcurrentOperationCount）来控制并发、串行。
NSOperationQueue 为我们提供了两种不同类型的队列：主队列和自定义队列。主队列运行在主线程之上，而自定义队列在后台执行。

2. NSOpeartion

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

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

2.1 NSOperation属性和方法


- (void)start; 开始执行操作。会执行若干检查，以确保操作可以实际运行。例如，如果接收器被cancel或已经finished，这个方法只返回而不调用main。
- (void)cancel; 可取消操作，实质是标记 isCancelled 状态。此方法不会强制停止操作代码。相反，它更新对象的内部标志来反映状态的变化。

- (void)main; 继承NSOperation的子类，可以在main方法中写任务代码。

- (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，单独使用 NSOperation 的情况下系统同步执行操作，下面我们学习以下操作的三种创建方式。

2.2 NSInvocationOperation

#import "ViewController.h"

@interface ViewController ()

@property (nonatomic, strong) NSInvocationOperation *invocationOperation;

@end

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    
    _invocationOperation = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(invocationOperationStart) object:nil];
    [_invocationOperation start];
}

- (void)invocationOperationStart{
    for (NSInteger i = 0; i < 6; i++) {
        sleep(1);
        NSLog(@"currentThread - %@, index => %ld",[NSThread currentThread],i);
    }
}

@end

控制台输出：

2019-09-23 11:07:57.047589+0800 NSOperationTest[2265:122701] currentThread - <NSThread: 0x60000298a280>{number = 1, name = main}, index => 0
2019-09-23 11:07:58.048536+0800 NSOperationTest[2265:122701] currentThread - <NSThread: 0x60000298a280>{number = 1, name = main}, index => 1
2019-09-23 11:07:59.049151+0800 NSOperationTest[2265:122701] currentThread - <NSThread: 0x60000298a280>{number = 1, name = main}, index => 2
2019-09-23 11:08:00.050622+0800 NSOperationTest[2265:122701] currentThread - <NSThread: 0x60000298a280>{number = 1, name = main}, index => 3

我们可以看到当前线程是主线程，相当于直接执行invocationOperationStart方法。满足我们上面所提到的在不使用 NSOperationQueue，单独使用 NSOperation 的情况下系统同步执行操作。也就是说，假如当前线程是新创建的线程，那么operation的操作也是在这个新创建的线程上同步执行的。

2.3 NSBlockOperation

_blockOperation = [NSBlockOperation blockOperationWithBlock:^{
        for (NSInteger i = 0; i < 6; i++) {
            sleep(1);
            NSLog(@"blockOperation: currentThread - %@, index => %ld",[NSThread currentThread],i);
        }
    }];
[_blockOperation start];

这样执行完成之后，跟上面NSInvocationOperation输出是一样的，都是在当前线程上同步进行操作，会阻塞当前线程。

但是，NSBlockOperation还有一个addExecutionBlock:方法，通过addExecutionBlock: 就可以为 NSBlockOperation 添加额外的操作。这些操作（包括 blockOperationWithBlock 中的操作）可以在不同的线程中同时（并发）执行。只有当所有相关的操作已经完成执行时，才视为完成。

如果添加的操作多的话，blockOperationWithBlock: 中的操作也可能会在其他线程（非当前线程）中执行，这是由系统决定的，并不是说添加到blockOperationWithBlock:中的操作一定会在当前线程中执行。（可以使用addExecutionBlock:多添加几个操作试试）。

@interface ViewController ()

@property (nonatomic, strong) NSBlockOperation *blockOperation;

@end

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    
    _blockOperation = [NSBlockOperation blockOperationWithBlock:^{
        for (NSInteger i = 0; i < 6; i++) {
            sleep(1);
            NSLog(@"blockOperation: currentThread - %@, index => %ld",[NSThread currentThread],i);
        }
    }];
    
    [_blockOperation addExecutionBlock:^{
        for (NSInteger i = 0; i < 6; i++) {
            sleep(1);
            NSLog(@"addExecutionBlock1: currentThread - %@, index => %ld",[NSThread currentThread],i);
        }
    }];
    
    [_blockOperation addExecutionBlock:^{
        for (NSInteger i = 0; i < 6; i++) {
            sleep(1);
            NSLog(@"addExecutionBlock2: currentThread - %@, index => %ld",[NSThread currentThread],i);
        }
    }];
    
    [_blockOperation addExecutionBlock:^{
        for (NSInteger i = 0; i < 6; i++) {
            sleep(1);
            NSLog(@"addExecutionBlock3: currentThread - %@, index => %ld",[NSThread currentThread],i);
        }
    }];
    
    [_blockOperation addExecutionBlock:^{
        for (NSInteger i = 0; i < 6; i++) {
            sleep(1);
            NSLog(@"addExecutionBlock4: currentThread - %@, index => %ld",[NSThread currentThread],i);
        }
    }];
    
    [_blockOperation addExecutionBlock:^{
        for (NSInteger i = 0; i < 6; i++) {
            sleep(1);
            NSLog(@"addExecutionBlock5: currentThread - %@, index => %ld",[NSThread currentThread],i);
        }
    }];
    
    [_blockOperation start];
    
}

@end

输出：

2019-09-23 11:14:40.593208+0800 NSOperationTest[2363:127354] addExecutionBlock4: currentThread - <NSThread: 0x6000034fdc40>{number = 1, name = main}, index => 0
2019-09-23 11:14:40.593206+0800 NSOperationTest[2363:127395] addExecutionBlock3: currentThread - <NSThread: 0x6000034ba800>{number = 3, name = (null)}, index => 0
2019-09-23 11:14:40.593209+0800 NSOperationTest[2363:127393] addExecutionBlock1: currentThread - <NSThread: 0x6000034f9340>{number = 4, name = (null)}, index => 0
2019-09-23 11:14:40.593210+0800 NSOperationTest[2363:127394] addExecutionBlock2: currentThread - <NSThread: 0x6000034f3840>{number = 7, name = (null)}, index => 0
2019-09-23 11:14:40.593206+0800 NSOperationTest[2363:127392] addExecutionBlock5: currentThread - <NSThread: 0x6000034ba240>{number = 5, name = (null)}, index => 0
2019-09-23 11:14:40.593207+0800 NSOperationTest[2363:127391] blockOperation: currentThread - <NSThread: 0x6000034f2f00>{number = 6, name = (null)}, index => 0
2019-09-23 11:14:41.593662+0800 NSOperationTest[2363:127395] addExecutionBlock3: currentThread - <NSThread: 0x6000034ba800>{number = 3, name = (null)}, index => 1
2019-09-23 11:14:41.593665+0800 NSOperationTest[2363:127394] addExecutionBlock2: currentThread - <NSThread: 0x6000034f3840>{number = 7, name = (null)}, index => 1
2019-09-23 11:14:41.593678+0800 NSOperationTest[2363:127393] addExecutionBlock1: currentThread - <NSThread: 0x6000034f9340>{number = 4, name = (null)}, index => 1
2019-09-23 11:14:41.593670+0800 NSOperationTest[2363:127392] addExecutionBlock5: currentThread - <NSThread: 0x6000034ba240>{number = 5, name = (null)}, index => 1
2019-09-23 11:14:41.593662+0800 NSOperationTest[2363:127354] addExecutionBlock4: currentThread - <NSThread: 0x6000034fdc40>{number = 1, name = main}, index => 1
2019-09-23 11:14:41.593763+0800 NSOperationTest[2363:127391] blockOperation: currentThread - <NSThread: 0x6000034f2f00>{number = 6, name = (null)}, index => 1

可以看出：使用子类NSBlockOperation，并调用方法 AddExecutionBlock:的情况下，blockOperationWithBlock:方法中的操作和addExecutionBlock:中的操作是在不同的线程中异步执行的。

一般情况下，如果一个NSBlockOperation 对象封装了多个操作。NSBlockOperation 是否开启新线程，取决于操作的个数。如果添加的操作的个数多，就会自动开启新线程。当然开启的线程数是由系统来决定的。

2.4 自定义Operation

如果使用子类 NSInvocationOperation、NSBlockOperation 不能满足日常需求，我们可以使用自定义继承自NSOperation 的子类。可以通过重写 main或者 start 方法来定义自己的 NSOperation对象。重写main方法比较简单，我们不需要管理操作的状态属性 isExecuting和 isFinished。当 main 执行完返回的时候，这个操作就结束了。

重写start方法支持异步:

修改当前的状态
创建下载dataTask
错误的处理

当operation状态为finish时：

清除其它任务的依赖
将当前的任务移除
执行completionBlock

我们自定义一个CustomOperation继承于NSOperation:

.h文件
@interface CustomOperation : NSOperation

@end

.m文件

@implementation CustomOperation

- (void)main{
    for (NSInteger i = 0; i < 6; i++) {
        sleep(1);
        NSLog(@"currentThread - %@, index => %ld",[NSThread currentThread],i);
    }
}

@end

controller.m文件
#import "ViewController.h"
#import "CustomOperation.h"

@interface ViewController ()

@property (nonatomic, strong) CustomOperation *customOperation;

@end

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    
    _customOperation = [[CustomOperation alloc] init];
    [_customOperation start];
}

@end

此时，运行控制台输出：

2019-09-23 11:34:36.917751+0800 NSOperationTest[2489:138343] currentThread - <NSThread: 0x600002a82140>{number = 1, name = main}, index => 0
2019-09-23 11:34:37.918310+0800 NSOperationTest[2489:138343] currentThread - <NSThread: 0x600002a82140>{number = 1, name = main}, index => 1
2019-09-23 11:34:38.918838+0800 NSOperationTest[2489:138343] currentThread - <NSThread: 0x600002a82140>{number = 1, name = main}, index => 2
2019-09-23 11:34:39.919767+0800 NSOperationTest[2489:138343] currentThread - <NSThread: 0x600002a82140>{number = 1, name = main}, index => 3
2019-09-23 11:34:40.920847+0800 NSOperationTest[2489:138343] currentThread - <NSThread: 0x600002a82140>{number = 1, name = main}, index => 4
2019-09-23 11:34:41.921831+0800 NSOperationTest[2489:138343] currentThread - <NSThread: 0x600002a82140>{number = 1, name = main}, index => 5

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

3. NSOpeartionQueue

3.1 NSOperationQueue介绍

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

主队列
凡是添加到主队列中的操作，都会放到主线程中执行（注：不包括操作使用addExecutionBlock:添加的额外操作，额外操作可能在其他线程执行）。

// 主队列获取方法
NSOperationQueue *queue = [NSOperationQueue mainQueue];

自定义队列（非主队列）
添加到这种队列中的操作，就会自动放到子线程中执行。
同时包含了：串行、并发功能。

// 自定义队列创建方法
NSOperationQueue *queue = [[NSOperationQueue alloc] init];

3.2 将操作添加到队列中

上边我们说到 NSOperation 需要配合NSOperationQueue 来实现多线程。

那么我们需要将创建好的操作加入到队列中去。总共有两种方法：

3.2.1 使用addOperation

#import "CustomOperation.h"

@interface ViewController ()

@property (nonatomic, strong) CustomOperation *customOperation;

@end

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    
    CustomOperation *customOperation = [[CustomOperation alloc] init];
    
    NSInvocationOperation *invocationOperation = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(invocationOperationTest) object:nil];
    
    NSBlockOperation *blockOperation = [NSBlockOperation blockOperationWithBlock:^{
        for (NSInteger i = 0; i < 6; i++) {
            sleep(1);
            NSLog(@"blockOperation: currentThread - %@, index => %ld",[NSThread currentThread],i);
        }
    }];
    
    [blockOperation addExecutionBlock:^{
        for (NSInteger i = 0; i < 6; i++) {
            sleep(1);
            NSLog(@"addExecutionBlock1: currentThread - %@, index => %ld",[NSThread currentThread],i);
        }
    }];
    
    [blockOperation addExecutionBlock:^{
        for (NSInteger i = 0; i < 6; i++) {
            sleep(1);
            NSLog(@"addExecutionBlock2: currentThread - %@, index => %ld",[NSThread currentThread],i);
        }
    }];
    
    
    NSOperationQueue *mainQueue = [[NSOperationQueue alloc] init];
    mainQueue.maxConcurrentOperationCount = 3;
    
    [mainQueue addOperation:customOperation];
    [mainQueue addOperation:blockOperation];
    [mainQueue addOperation:invocationOperation];
}

- (void)invocationOperationTest{
    for (NSInteger i = 0; i < 6; i++) {
        sleep(1);
        NSLog(@"invocationOperation: currentThread - %@, index => %ld",[NSThread currentThread],i);
    }
}

@end

控制台输出：

2019-09-23 11:57:25.657532+0800 NSOperationTest[2699:154662] addExecutionBlock1: currentThread - <NSThread: 0x600002718e80>{number = 3, name = (null)}, index => 0
2019-09-23 11:57:25.657537+0800 NSOperationTest[2699:154664] blockOperation: currentThread - <NSThread: 0x600002736a00>{number = 8, name = (null)}, index => 0
2019-09-23 11:57:25.657537+0800 NSOperationTest[2699:154661] customOperation: currentThread - <NSThread: 0x600002718c80>{number = 7, name = (null)}, index => 0
2019-09-23 11:57:25.657537+0800 NSOperationTest[2699:154665] invocationOperation: currentThread - <NSThread: 0x60000276c600>{number = 5, name = (null)}, index => 0
2019-09-23 11:57:25.657551+0800 NSOperationTest[2699:154663] addExecutionBlock2: currentThread - <NSThread: 0x600002768b00>{number = 4, name = (null)}, index => 0
2019-09-23 11:57:26.661176+0800 NSOperationTest[2699:154661] customOperation: currentThread - <NSThread: 0x600002718c80>{number = 7, name = (null)}, index => 1
2019-09-23 11:57:26.661173+0800 NSOperationTest[2699:154665] invocationOperation: currentThread - <NSThread: 0x60000276c600>{number = 5, name = (null)}, index => 1
2019-09-23 11:57:26.661173+0800 NSOperationTest[2699:154664] blockOperation: currentThread - <NSThread: 0x600002736a00>{number = 8, name = (null)}, index => 1
2019-09-23 11:57:26.661181+0800 NSOperationTest[2699:154662] addExecutionBlock1: currentThread - <NSThread: 0x600002718e80>{number = 3, name = (null)}, index => 1
2019-09-23 11:57:26.661174+0800 NSOperationTest[2699:154663] addExecutionBlock2: currentThread - <NSThread: 0x600002768b00>{number = 4, name = (null)}, index => 1
2019-09-23 11:57:27.665054+0800 NSOperationTest[2699:154661] customOperation: currentThread - <NSThread: 0x600002718c80>{number = 7, name = (null)}, index => 2
2019-09-23 11:57:27.665054+0800 NSOperationTest[2699:154665] invocationOperation: currentThread - <NSThread: 0x60000276c600>{number = 5, name = (null)}, index => 2
2019-09-23 11:57:27.665054+0800 NSOperationTest[2699:154662] addExecutionBlock1: currentThread - <NSThread: 0x600002718e80>{number = 3, name = (null)}, index => 2
2019-09-23 11:57:27.665054+0800 NSOperationTest[2699:154663] addExecutionBlock2: currentThread - <NSThread: 0x600002768b00>{number = 4, name = (null)}, index => 2
2019-09-23 11:57:27.665078+0800 NSOperationTest[2699:154664] blockOperation: currentThread - <NSThread: 0x600002736a00>{number = 8, name = (null)}, index => 2
2019-09-23 11:57:28.669199+0800 NSOperationTest[2699:154665] invocationOperation: currentThread - <NSThread: 0x60000276c600>{number = 5, name = (null)}, index => 3
2019-09-23 11:57:28.669201+0800 NSOperationTest[2699:154661] customOperation: currentThread - <NSThread: 0x600002718c80>{number = 7, name = (null)}, index => 3
...

可以看出使用 NSOperation 子类创建操作，并使用 addOperation:将操作加入到操作队列后能够开启新线程，进行并发执行。

3.2.2 使用addOperationWithBlock

无需先创建操作，在 block中添加操作，直接将包含操作的 block 加入到队列中。

@interface ViewController ()

@end

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];;
    queue.maxConcurrentOperationCount = 3;
    
    [queue addOperationWithBlock:^{
        for (NSInteger i = 0; i < 6; i++) {
            sleep(1);
            NSLog(@"OperationWithBlock1: currentThread - %@, index => %ld",[NSThread currentThread],i);
        }
    }];
    
    [queue addOperationWithBlock:^{
        for (NSInteger i = 0; i < 6; i++) {
            sleep(1);
            NSLog(@"OperationWithBlock2: currentThread - %@, index => %ld",[NSThread currentThread],i);
        }
    }];
    
    [queue addOperationWithBlock:^{
        for (NSInteger i = 0; i < 6; i++) {
            sleep(1);
            NSLog(@"OperationWithBlock3: currentThread - %@, index => %ld",[NSThread currentThread],i);
        }
    }];
}

@end

输出结果:

2019-09-23 13:36:53.715723+0800 NSOperationTest[2855:184521] OperationWithBlock2: currentThread - <NSThread: 0x60000261ad80>{number = 5, name = (null)}, index => 0
2019-09-23 13:36:53.715723+0800 NSOperationTest[2855:184524] OperationWithBlock3: currentThread - <NSThread: 0x60000265ea40>{number = 3, name = (null)}, index => 0
2019-09-23 13:36:53.715723+0800 NSOperationTest[2855:184523] OperationWithBlock1: currentThread - <NSThread: 0x6000026d2cc0>{number = 7, name = (null)}, index => 0
2019-09-23 13:36:54.720633+0800 NSOperationTest[2855:184524] OperationWithBlock3: currentThread - <NSThread: 0x60000265ea40>{number = 3, name = (null)}, index => 1
2019-09-23 13:36:54.720633+0800 NSOperationTest[2855:184523] OperationWithBlock1: currentThread - <NSThread: 0x6000026d2cc0>{number = 7, name = (null)}, index => 1
2019-09-23 13:36:54.720641+0800 NSOperationTest[2855:184521] OperationWithBlock2: currentThread - <NSThread: 0x60000261ad80>{number = 5, name = (null)}, index => 1
2019-09-23 13:36:55.725485+0800 NSOperationTest[2855:184524] OperationWithBlock3: currentThread - <NSThread: 0x60000265ea40>{number = 3, name = (null)}, index => 2
2019-09-23 13:36:55.725516+0800 NSOperationTest[2855:184523] OperationWithBlock1: currentThread - <NSThread: 0x6000026d2cc0>{number = 7, name = (null)}, index => 2
2019-09-23 13:36:55.725511+0800 NSOperationTest[2855:184521] OperationWithBlock2: currentThread - <NSThread: 0x60000261ad80>{number = 5, name = (null)}, index => 2
2019-09-23 13:36:56.730603+0800 NSOperationTest[2855:184521] OperationWithBlock2: currentThread - <NSThread: 0x60000261ad80>{number = 5, name = (null)}, index => 3
2019-09-23 13:36:56.730603+0800 NSOperationTest[2855:184524] OperationWithBlock3: currentThread - <NSThread: 0x60000265ea40>{number = 3, name = (null)}, index => 3
2019-09-23 13:36:56.730628+0800 NSOperationTest[2855:184523] OperationWithBlock1: currentThread - <NSThread: 0x6000026d2cc0>{number = 7, name = (null)}, index => 3
2019-09-23 13:36:57.733808+0800 NSOperationTest[2855:184521] OperationWithBlock2: currentThread - <NSThread: 0x60000261ad80>{number = 5, name = (null)}, index => 4
2019-09-23 13:36:57.733808+0800 NSOperationTest[2855:184524] OperationWithBlock3: currentThread - <NSThread: 0x60000265ea40>{number = 3, name = (null)}, index => 4
2019-09-23 13:36:57.733808+0800 NSOperationTest[2855:184523] OperationWithBlock1: currentThread - <NSThread: 0x6000026d2cc0>{number = 7, name = (null)}, index => 4
2019-09-23 13:36:58.736158+0800 NSOperationTest[2855:184521] OperationWithBlock2: currentThread - <NSThread: 0x60000261ad80>{number = 5, name = (null)}, index => 5
2019-09-23 13:36:58.736162+0800 NSOperationTest[2855:184524] OperationWithBlock3: currentThread - <NSThread: 0x60000265ea40>{number = 3, name = (null)}, index => 5
2019-09-23 13:36:58.736173+0800 NSOperationTest[2855:184523] OperationWithBlock1: currentThread - <NSThread: 0x6000026d2cc0>{number = 7, name = (null)}, index => 5

同样会创建新线程，异步并发执行。

3.3 NSOperationQueue 控制串行执行、并发执行

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

这里有个关键属性maxConcurrentOperationCount，叫做最大并发操作数。用来控制一个特定队列中可以有多少个操作同时参与并发执行。

注意：这里 maxConcurrentOperationCount 控制的不是并发线程的数量，而是一个队列中同时能并发执行的最大操作数。而且一个操作也并非只能在一个线程中运行。

最大并发操作数：maxConcurrentOperationCount

maxConcurrentOperationCount 默认情况下为-1，表示不进行限制，可进行并发执行。
maxConcurrentOperationCount 为1时，队列为串行队列。只能串行执行。
maxConcurrentOperationCount大于1时，队列为并发队列。操作并发执行，当然这个值不应超过系统限制，即使自己设置一个很大的值，系统也会自动调整为 min{自己设定的值，系统设定的默认最大值}。

这里可以自己写个demo验证一下，使用自定义队列，添加多个任务，设置maxConcurrentOperationCount = 1时，是串行执行，设置maxConcurrentOperationCount > 1是并发执行。

3.4 NSOperation 操作依赖

NSOperation、NSOperationQueue 最吸引人的地方是它能添加操作之间的依赖关系。通过操作依赖，我们可以很方便的控制操作之间的执行先后顺序。NSOperation 提供了3个接口供我们管理和查看依赖。

- (void)addDependency:(NSOperation *)op; 添加依赖，使当前操作依赖于操作 op 的完成。
- (void)removeDependency:(NSOperation *)op; 移除依赖，取消当前操作对操作 op 的依赖。
@property (readonly, copy) NSArray<NSOperation *> *dependencies; 在当前操作开始执行之前完成执行的所有操作对象数组。

NSOperation支持的依赖项并不区分依赖项操作是否成功完成。(换句话说，取消一个操作类似地将其标记为已完成)。在依赖operation被cancenl或没有成功完成任务的情况下，再决定是否应该继续执行具有依赖项的操作。这可能需要将额外的错误跟踪功能合并到operation中。

注意：上面有提到，当一个任务B所依赖的任务A还没有执行完成的时候，任务B是处于非ready状态的，只有当A执行完成了（B所依赖的任务全部完成了），任务B才会变成ready状态。

当然，我们经常用到的还是添加依赖操作。现在考虑这样的需求，比如说有 A、B 两个操作，其中 A 执行完操作，B 才能执行操作。

如果使用依赖来处理的话，那么就需要让操作 B依赖于操作 A。具体代码如下：

@interface ViewController ()

@end

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    
    
    NSBlockOperation *blockOperationA = [NSBlockOperation blockOperationWithBlock:^{
        for (NSInteger i = 0; i < 5; i++) {
            sleep(1);
            NSLog(@"blockOperationA: currentThread - %@, index => %ld",[NSThread currentThread],i);
        }
    }];
    
    NSBlockOperation *blockOperationB = [NSBlockOperation blockOperationWithBlock:^{
        for (NSInteger i = 0; i < 5; i++) {
            sleep(1);
            NSLog(@"blockOperationB: currentThread - %@, index => %ld",[NSThread currentThread],i);
        }
    }];
    
    NSBlockOperation *blockOperationC = [NSBlockOperation blockOperationWithBlock:^{
        for (NSInteger i = 0; i < 5; i++) {
            sleep(1);
            NSLog(@"blockOperationC: currentThread - %@, index => %ld",[NSThread currentThread],i);
        }
    }];
    
    [blockOperationB addDependency:blockOperationA];
    
    blockOperationA.completionBlock = ^{
        if (blockOperationB.isReady) {
            NSLog(@"任务A执行完成之后operationB准备好了");
        }else{
            NSLog(@"任务A执行完成之后operationB没有准备好");
        }
    };
    
    if (blockOperationB.isReady) {
        NSLog(@"添加到队列之前operationB准备好了");
    }else{
        NSLog(@"添加到队列之前operationB没有准备好");
    }
    
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];
    [queue addOperation:blockOperationA];
    [queue addOperation:blockOperationB];
    [queue addOperation:blockOperationC];
}
@end

控制台输出：

2019-09-23 13:49:56.608968+0800 NSOperationTest[3052:193320] 添加到队列之前operationB没有准备好
2019-09-23 13:49:57.614244+0800 NSOperationTest[3052:193476] blockOperationA: currentThread - <NSThread: 0x600003e6acc0>{number = 3, name = (null)}, index => 0
2019-09-23 13:49:57.614239+0800 NSOperationTest[3052:193472] blockOperationC: currentThread - <NSThread: 0x600003e6ca00>{number = 6, name = (null)}, index => 0
2019-09-23 13:49:58.619598+0800 NSOperationTest[3052:193476] blockOperationA: currentThread - <NSThread: 0x600003e6acc0>{number = 3, name = (null)}, index => 1
2019-09-23 13:49:58.619657+0800 NSOperationTest[3052:193472] blockOperationC: currentThread - <NSThread: 0x600003e6ca00>{number = 6, name = (null)}, index => 1
2019-09-23 13:49:59.623347+0800 NSOperationTest[3052:193472] blockOperationC: currentThread - <NSThread: 0x600003e6ca00>{number = 6, name = (null)}, index => 2
2019-09-23 13:49:59.623347+0800 NSOperationTest[3052:193476] blockOperationA: currentThread - <NSThread: 0x600003e6acc0>{number = 3, name = (null)}, index => 2
2019-09-23 13:50:00.628615+0800 NSOperationTest[3052:193476] blockOperationA: currentThread - <NSThread: 0x600003e6acc0>{number = 3, name = (null)}, index => 3
2019-09-23 13:50:00.628617+0800 NSOperationTest[3052:193472] blockOperationC: currentThread - <NSThread: 0x600003e6ca00>{number = 6, name = (null)}, index => 3
2019-09-23 13:50:01.632175+0800 NSOperationTest[3052:193476] blockOperationA: currentThread - <NSThread: 0x600003e6acc0>{number = 3, name = (null)}, index => 4
2019-09-23 13:50:01.632175+0800 NSOperationTest[3052:193472] blockOperationC: currentThread - <NSThread: 0x600003e6ca00>{number = 6, name = (null)}, index => 4
2019-09-23 13:50:01.632483+0800 NSOperationTest[3052:193476] 任务A执行完成之后operationB准备好了
2019-09-23 13:50:02.636373+0800 NSOperationTest[3052:193472] blockOperationB: currentThread - <NSThread: 0x600003e6ca00>{number = 6, name = (null)}, index => 0
2019-09-23 13:50:03.638088+0800 NSOperationTest[3052:193472] blockOperationB: currentThread - <NSThread: 0x600003e6ca00>{number = 6, name = (null)}, index => 1
2019-09-23 13:50:04.639857+0800 NSOperationTest[3052:193472] blockOperationB: currentThread - <NSThread: 0x600003e6ca00>{number = 6, name = (null)}, index => 2
2019-09-23 13:50:05.643648+0800 NSOperationTest[3052:193472] blockOperationB: currentThread - <NSThread: 0x600003e6ca00>{number = 6, name = (null)}, index => 3
2019-09-23 13:50:06.647131+0800 NSOperationTest[3052:193472] blockOperationB: currentThread - <NSThread: 0x600003e6ca00>{number = 6, name = (null)}, index => 4

我们可以看到，
-operationB一直到operationA执行完成后才会变成准备好的状态。

operationA和operationC是并发执行，operationB等到其所依赖的任务A完成后，才去执行的。

3.5 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 都不是准备就绪状态下的操作。

可以使用addDependency:和removeDependency:方法为操作添加和删除依赖项。默认情况下，具有依赖项的operation在所有依赖的operation都执行完之前不会被认为已经准备好。然而，一旦最后一个依赖operation完成，操作对象就准备好并能够执行了(ready)。

理解了进入就绪状态的操作，那么我们就理解了queuePriority 属性的作用对象。

queuePriority 属性决定了进入准备就绪状态下的操作之间的开始执行顺序。并且，优先级不能取代依赖关系。并且优先级并不能完全决定开始执行顺序。
如果一个队列中既包含高优先级操作，又包含低优先级操作，并且两个操作都已经准备就绪，那么队列先执行高优先级操作。比如上例中，如果op1和 op4是不同优先级的操作，那么就会先执行优先级高的操作。
如果，一个队列中既包含了准备就绪状态的操作，又包含了未准备就绪的操作，未准备就绪的操作优先级比准备就绪的操作优先级高。那么，虽然准备就绪的操作优先级低，也会优先执行。优先级不能取代依赖关系。如果要控制操作间的启动顺序，则必须使用依赖关系。

3.6 `NSOperation、NSOperationQueue`线程间的通信

在iOS 开发过程中，我们一般在主线程里边进行 UI刷新，例如：点击、滚动、拖拽等事件。我们通常把一些耗时的操作放在其他线程，比如说图片下载、文件上传等耗时操作。而当我们有时候在其他线程完成了耗时操作时，需要回到主线程，那么就用到了线程之间的通讯。

/**
 * 线程间通信
 */
- (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]); // 打印当前线程
            }
        }];
    }];
}

通过线程间的通信，先在其他线程中执行操作，等操作执行完了之后再回到主线程执行主线程的相应操作。

3.7 `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; 获取主队列。

注意：cancel操作不会立即停止正在执行的操作。尽管所有操作都需要考虑cancel属性中的值，但代码中必须显式地检查cancel属性中的值，并根据需要中止。
NSOperation的开始执行之前会有取消状态检查。例如，如果在调用某个操作的start方法之前调用cancel方法，则start方法将不启动该任务而退出。

最后编辑于：2021.01.24 16:56:59

人面猴
序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
沈念sama阅读 219,539评论 6赞 508
死咒
序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
沈念sama阅读 93,594评论 3赞 396
救了他两次的神仙让他今天三更去死
文/潘晓璐我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
开封第一讲书人阅读 165,871评论 0赞 356
道士缉凶录：失踪的卖姜人
文/不坏的土叔我叫张陵，是天一观的道长。经常有香客问我，道长，这世上最难降的妖魔是什么？我笑而不...
开封第一讲书人阅读 58,963评论 1赞 295
港岛之恋（遗憾婚礼）
正文为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
茶点故事阅读 67,984评论 6赞 393
恶毒庶女顶嫁案：这布局不是一般人想出来的
文/花漫我一把揭开白布。她就那样静静地躺着，像睡着了一般。火红的嫁衣衬着肌肤如雪。梳的纹丝不乱的头发上，一...
开封第一讲书人阅读 51,763评论 1赞 307
城市分裂传说
那天，我揣着相机与录音，去河边找鬼。笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。我是一名探鬼主播，决...
沈念sama阅读 40,468评论 3赞 420
双鸳鸯连环套：你想象不到人心有多黑
文/苍兰香墨我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
开封第一讲书人阅读 39,357评论 0赞 276
万荣杀人案实录
序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
沈念sama阅读 45,850评论 1赞 317
护林员之死
正文独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋以下内容为张勋视角年9月15日...
茶点故事阅读 38,002评论 3赞 338
白月光启示录
正文我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
茶点故事阅读 40,144评论 1赞 351
活死人
序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
沈念sama阅读 35,823评论 5赞 346
日本核电站爆炸内幕
正文年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
茶点故事阅读 41,483评论 3赞 331
男人毒药：我在死后第九天来索命
文/蒙蒙一、第九天我趴在偏房一处隐蔽的房顶上张望。院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
开封第一讲书人阅读 32,026评论 0赞 22
一桩弑父案，背后竟有这般阴谋
文/苍兰香墨我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。一阵脚步声响...
开封第一讲书人阅读 33,150评论 1赞 272
情欲美人皮
我被黑心中介骗来泰国打工，没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。一个月前我还...
沈念sama阅读 48,415评论 3赞 373
代替公主和亲
正文我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
茶点故事阅读 45,092评论 2赞 355

[iOS] 多线程之NSOperation

1. 基础知识

1.1 NSOperation

1.2 操作队列（Operation Queues）

2. NSOpeartion

2.1 NSOperation属性和方法

2.2 NSInvocationOperation

2.3 NSBlockOperation

2.4 自定义Operation

3. NSOpeartionQueue

3.1 NSOperationQueue介绍

3.2 将操作添加到队列中

3.2.1 使用addOperation

3.2.2 使用addOperationWithBlock

3.3 NSOperationQueue 控制串行执行、并发执行

3.4 NSOperation 操作依赖

3.5 NSOperation 操作优先级

3.6 NSOperation、NSOperationQueue线程间的通信

3.7 NSOperationQueue 常用属性和方法

推荐阅读更多精彩内容

3.6 `NSOperation、NSOperationQueue`线程间的通信

3.7 `NSOperationQueue` 常用属性和方法