iOS 多线程之NSOperation、NSOperationQueue

NSOperation、NSOperationQueue 是苹果为我们提供的一项多线程解决方案，它是对 GCD 的更高一层的封装，面向对象。比起GCD更加简单易用、代码可读性也更好。

基本认识

在 NSOperation 中也有类似任务和队列的概念。我们把任务称作操作，把队列称作操作队列。

操作（Operation）：执行操作的意思，换句话说就是你在线程中执行的那段代码。
在 GCD 中是放在 block 中的。在 NSOperation 中，我们使用 NSOperation 子类 NSInvocationOperation、NSBlockOperation，或者自定义子类来封装操作
操作队列：即存放操作的队列。不同与 GCD 中的调度队列FIFO原则。NSOperationQueue 对于添加到队列中的操作，首先进入准备就绪的状态（就绪状态取决于操作之间的依赖关系），然后进入就绪状态的操作的开始执行顺序由操作之间的相对优先级决定（优先级是操作对象自身的属性）。操作队列通过设置最大并发操作数来控制并发、串行。NSOperationQueue 为我们提供了两种队列：主队列和自定义队列。主队列运行在主线程之上，而自定义队列在后台执行。

NSOperation、NSOperationQueue 的使用

NSOperation 需要配合 NSOperationQueue 来实现多线程。因为默认情况下，NSOperation 单独使用时系统同步执行操作，配合 NSOperationQueue 我们可以更好的实现异步执行。

NSOperation 实现多线程的使用步骤：

创建操作：先将需要执行的操作封装到一个 NSOperation 对象中
创建队列：创建 NSOperationQueue 对象
将操作加入到队列中：将 NSOperation 对象添加到 NSOperationQueue 对象中。

之后，系统就会自动将 NSOperationQueue 中的 NSOperation 取出来，在新线程中执行。

下面，我们通过代码具体来学习

创建操作

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

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

注：在不使用 NSOperationQueue,单独使用 NSOperation 的情况下系统会同步执行操作，不会开辟新线程。

NSInvocationOperation

  // 1. 创建 NSInvocationOPeration
    NSInvocationOperation *invocationOp = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(task1) object:nil];
    // 2. 调用 start 方法开始执行
    [invocationOp start];
    
    ----
    操作：
    - (void)task1 {
    for (int i = 0; i < 2; i++) {
        [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
        NSLog(@"1---%@", [NSThread currentThread]); // 打印当前线程
    }
}

通过输出，我们会发现在没有使用 NSOperationQueue、在主线程中单独使用使用子类 NSInvocationOperation 执行一个操作的情况下，操作是在当前线程执行的，并没有开启新线程。

如果在其他线程中执行操作，则打印结果为其他线程。

NSBlockOperation

// 1. 创建 NSBlockOperation 对象
    NSBlockOperation *blockOp = [NSBlockOperation blockOperationWithBlock:^{
        for (int i = 0;  i < 2; i++) {
            [NSThread sleepForTimeInterval:2];
            NSLog(@"1--%@", [NSThread currentThread]);
        }
    }];
    
    // 2. 调用 start 方法开始执行操作
    [blockOp start];

和 NSInvocationQueue 结果一样操作是在当前线程执行的，并没有开启新线程，如果在其他线程中执行操作，则打印结果为其他线程。

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

[blockOp addExecutionBlock:^{
       for (int i = 0;  i < 2; i++) {
           [NSThread sleepForTimeInterval:2];
           NSLog(@"2--%@", [NSThread currentThread]);
       }
   }];

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

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

自定义 NSOperation

如果使用子类 NSInvocationOperation、NSBlockOperation 不能满足日常需求，我们可以使用自定义继承自 NSOperation 的子类。可以通过重写 main 或者 start 方法来定义自己的 NSOperation 对象。

创建队列

NSOperation 一共有两种队列：主队列、自定义队列。其中自定义队列同时包含了串行、并发功能。

主队列

凡是添加到主队列中的操作，都会放到主线程中执行。

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

自定义队列（非主队列）

1 2	/// 自定义队列获取方法 NSOperationQueue *queue = [NSOperationQueue alloc] init];

将操作加入到队列中

NSOperation 需要配合 NSOperationQueue 来实现多线程。有两种方法可以将创建好的操作加入到队列中。

addOperation: 方法

需要先创建操作，再将创建好的操作加入到创建好的队列中去。使用 NSOperation 子类创建操作，并使用 addOperation: 将操作加入到操作队列后能够开启新线程，进行并发执行。

NSOperationQueue *queue = [[NSOperationQueue alloc] init];
[queue addOperation:blockOp];
[queue addOperation:blockOp1];
[queue addOperation:invocationOp];

addOperationWithBlock:

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

NSOperationQueue *queue = [[NSOperationQueue alloc] init];
   
   [queue addOperationWithBlock:^{
       for (int i = 0;  i < 2; i++) {
           [NSThread sleepForTimeInterval:2];
           NSLog(@"1--%@", [NSThread currentThread]);
       }
   }];

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

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

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

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

NSOperation

操作依赖

NSOperation、NSOperationQueue 它能添加操作之间的额依赖关系。通过操作依赖，我们可以方便的控制操作之间的执行先后顺序。NSOperation 提供了三个接口：

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

比如，有A、B两个操作，我们需要A执行完操作，B才能执行操作。这样，我们可以通过让 B 依赖于操作A。

1 2	// 添加依赖 [op2 addDependency:op1]; // 让op2 依赖于 op1，则先执行op1，在执行op2

优先级

NSOperation 提供了queuePriority（优先级）属性，queuePriority属性适用于同一操作队列中的操作，不适用于不同操作队列中的操作。默认情况下，所有新创建的操作对象优先级都是NSOperationQueuePriorityNormal。但是我们可以通过setQueuePriority:方法来改变当前操作在同一队列中的执行优先级。

// 优先级的取值
typedef NS_ENUM(NSInteger, NSOperationQueuePriority) {
    NSOperationQueuePriorityVeryLow = -8L,
    NSOperationQueuePriorityLow = -4L,
    NSOperationQueuePriorityNormal = 0,
    NSOperationQueuePriorityHigh = 4,
    NSOperationQueuePriorityVeryHigh = 8
};

之前，我们说过对于添加到队列中的操作，首先进入准备就绪状态（就绪状态取决于操作之间的依赖关系），然后进入就绪状态的操作开始执行顺序由操作之间相对的优先级决定。

当一个操作的所有依赖都完成时，才算是进入就绪状态的操作。

并且优先级不能取代依赖关系。

常用的属性

NSOperation 的常见属性

取消操作方法

1	-(void)cancel; //可取消操作，实质是标记 isCancelled 状态。

判断操作状态方法

- (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; //在当前操作开始执行之前完成执行的所有操作对象数组。

NSOperation 的常见属性

取消/暂停/恢复操作

1
2
3

- (void)cancelAllOperations; // 可以取消队列的所有操作。
- (BOOL)isSuspended; //判断队列是否处于暂停状态。 YES 为暂停状态，NO 为恢复状态。
- (void)setSuspended:(BOOL)b; //可设置操作的暂停和恢复，YES 代表暂停队列，NO 代表恢复队列。

操作同步

1	- (void)waitUntilAllOperationsAreFinished; //阻塞当前线程，直到队列中的操作全部执行完毕。

添加/获取操作

- (void)addOperationWithBlock:(void (^)(void))block; 向队列中添加一个 NSBlockOperation 类型操作对象。
- (void)addOperations:(NSArray *)ops waitUntilFinished:(BOOL)wait; 向队列中添加操作数组，wait 标志是否阻塞当前线程直到所有操作结束
- (NSArray *)operations; 当前在队列中的操作数组（某个操作执行结束后会自动从这个数组清除）。
- (NSUInteger)operationCount; 当前队列中的操作数。

获取队列

1 2	+ (id)currentQueue; //获取当前队列，如果当前线程不是在 NSOperationQueue 上运行则返回 nil。 + (id)mainQueue; //获取主队列。

注意：

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

NSOperation、NSOperationQueue 线程通信、线程安全及线程同步问题

线程通信：在 iOS 开发过程中，我们一般在主线程里边进行 UI 刷新，例如：点击、滚动、拖拽等事件。我们通常把一些耗时的操作放在其他线程，比如说图片下载、文件上传等耗时操作。而当我们有时候在其他线程完成了耗时操作时，需要回到主线程，那么就用到了线程之间的通讯。
线程安全：如果你的代码所在的进程中有多个线程在同时运行，而这些线程可能会同时运行这段代码。如果每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。若每个线程中对全局变量、静态变量只有读操作，而无写操作，一般来说，这个全局变量是线程安全的；若有多个线程同时执行写操作（更改变量），一般都需要考虑线程同步，否则的话就可能影响线程安全。
线程同步：可理解为线程 A 和线程 B 一块配合，A 执行到一定程度时要依靠线程 B 的某个结果，于是停下来，示意 B 运行；B 依言执行，再将结果给 A；A 再继续操作。

基本认识

NSOperation、NSOperationQueue 的使用

创建操作

NSInvocationOperation

NSBlockOperation

自定义 NSOperation

创建队列

将操作加入到队列中

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

NSOperation

操作依赖

优先级

常用的属性

NSOperation 的常见属性

NSOperation 的常见属性

NSOperation、NSOperationQueue 线程通信、线程安全及线程同步问题

FEATURED TAGS

FRIENDS