iOS 多线程：『NSOperation、NSOperationQueue』详尽总结

时间 2019-11-08

标签 ios 多线程 nsoperation nsoperationqueue 详尽总结栏目 iOS 繁體版

原文原文链接

本文用来介绍 iOS 多线程中 NSOperation、NSOperationQueue 的相关知识以及使用方法。经过本文，您将了解到： NSOperation、NSOperationQueue 简介、操做和操做队列、使用步骤和基本使用方法、控制串行/并发执行、NSOperation 操做依赖和优先级、线程间的通讯、线程同步和线程安全，以及 NSOperation、NSOperationQueue 经常使用属性和方法概括。html

1. NSOperation、NSOperationQueue 简介

NSOperation、NSOperationQueue是苹果提供给咱们的一套多线程解决方案。实际上 NSOperation、NSOperationQueue 是基于 GCD更高一层的封装，彻底面向对象。可是比 GCD更简单易用、代码可读性也更高。编程

为何要使用 NSOperation、NSOperationQueue？数组

可添加完成的代码块，在操做完成后执行。
添加操做之间的依赖关系，方便的控制执行顺序。
设定操做执行的优先级。
能够很方便的取消一个操做的执行。
使用 KVO 观察对操做执行状态的更改：isExecuteing、isFinished、isCancelled。

2. NSOperation、NSOperationQueue 操做和操做队列

既然是基于 GCD 的更高一层的封装。那么，GCD 中的一些概念一样适用于 NSOperation、NSOperationQueue。在 NSOperation、NSOperationQueue 中也有相似的 任务（操做） 和 队列（操做队列） 的概念。安全

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

3. NSOperation、NSOperationQueue 使用步骤

NSOperation 须要配合 NSOperationQueue来实现多线程。由于默认状况下，NSOperation 单独使用时系统同步执行操做，配合 NSOperationQueue 咱们能更好的实现异步执行。bash

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

1 建立操做：先将须要执行的操做封装到一个 NSOperation 对象中。
2 建立队列：建立 NSOperationQueue 对象。
3 将操做加入到队列中：将 NSOperation 对象添加到 NSOperationQueue 对象中。

以后，系统就会自动将 NSOperationQueue 中的 NSOperation 取出来，在新线程中执行操做。并发

下面咱们来学习下 NSOperation 和 NSOperationQueue 的基本使用。app

4. NSOperation 和 NSOperationQueue 基本使用

4.1 建立操做

NSOperation 是个抽象类，不能用来封装操做。咱们只有使用它的子类来封装操做。咱们有三种方式来封装操做。异步

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

在不使用 NSOperationQueue，单独使用 NSOperation 的状况下系统同步执行操做，下面咱们学习如下操做的三种建立方式。ide

4.1.1 使用子类 NSInvocationOperation

/**
 * 使用子类 NSInvocationOperation
 */
- (void)useInvocationOperation {

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

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

/**
 * 任务1
 */
- (void)task1 {
    for (int i = 0; i < 2; i++) {
        [NSThread sleepForTimeInterval:2]; // 模拟耗时操做
        NSLog(@"1---%@", [NSThread currentThread]); // 打印当前线程
    }
}

复制代码

输出结果：

能够看到：在没有使用 NSOperationQueue、在主线程中单独使用使用子类 NSInvocationOperation执行一个操做的状况下，操做是在当前线程执行的，并无开启新线程。

若是在其余线程中执行操做，则打印结果为其余线程。

// 在其余线程使用子类 NSInvocationOperation
[NSThread detachNewThreadSelector:@selector(useInvocationOperation) toTarget:self withObject:nil];
复制代码

输出结果：

能够看到：在其余线程中单独使用子类 NSInvocationOperation，操做是在当前调用的其余线程执行的，并无开启新线程。下边再来看看 NSBlockOperation。

4.1.2 使用子类 NSBlockOperation

/** * 使用子类 NSBlockOperation */
- (void)useBlockOperation {

    // 1.建立 NSBlockOperation 对象
    NSBlockOperation *op = [NSBlockOperation blockOperationWithBlock:^{
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模拟耗时操做
            NSLog(@"1---%@", [NSThread currentThread]); // 打印当前线程
        }
    }];

    // 2.调用 start 方法开始执行操做
    [op start];
}
复制代码

输出结果：

能够看到：在没有使用 NSOperationQueue、在主线程中单独使用 NSBlockOperation 执行一个操做的状况下，操做是在当前线程执行的，并无开启新线程。

注意：和上边 NSInvocationOperation 使用同样。由于代码是在主线程中调用的，因此打印结果为主线程。若是在其余线程中执行操做，则打印结果为其余线程。

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

若是添加的操做多的话，blockOperationWithBlock: 中的操做也可能会在其余线程（非当前线程）中执行，这是由系统决定的，并非说添加到blockOperationWithBlock:中的操做必定会在当前线程中执行。（可使用 addExecutionBlock:多添加几个操做试试）。

/**
 * 使用子类 NSBlockOperation
 * 调用方法 AddExecutionBlock:
 */
- (void)useBlockOperationAddExecutionBlock {

    // 1.建立 NSBlockOperation 对象
    NSBlockOperation *op = [NSBlockOperation blockOperationWithBlock:^{
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模拟耗时操做
            NSLog(@"1---%@", [NSThread currentThread]); // 打印当前线程
        }
    }];

    // 2.添加额外的操做
    [op addExecutionBlock:^{
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模拟耗时操做
            NSLog(@"2---%@", [NSThread currentThread]); // 打印当前线程
        }
    }];
    [op addExecutionBlock:^{
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模拟耗时操做
            NSLog(@"3---%@", [NSThread currentThread]); // 打印当前线程
        }
    }];
    [op addExecutionBlock:^{
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模拟耗时操做
            NSLog(@"4---%@", [NSThread currentThread]); // 打印当前线程
        }
    }];
    [op addExecutionBlock:^{
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模拟耗时操做
            NSLog(@"5---%@", [NSThread currentThread]); // 打印当前线程
        }
    }];
    [op addExecutionBlock:^{
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模拟耗时操做
            NSLog(@"6---%@", [NSThread currentThread]); // 打印当前线程
        }
    }];
    [op addExecutionBlock:^{
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模拟耗时操做
            NSLog(@"7---%@", [NSThread currentThread]); // 打印当前线程
        }
    }];
    [op addExecutionBlock:^{
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模拟耗时操做
            NSLog(@"8---%@", [NSThread currentThread]); // 打印当前线程
        }
    }];

    // 3.调用 start 方法开始执行操做
    [op start];
}
复制代码

输出结果：

能够看出：使用子类 NSBlockOperation，并调用方法 addExecutionBlock:的状况下，blockOperationWithBlock:方法中的操做和 addExecutionBlock:中的操做是在不一样的线程中异步执行的。并且，此次执行结果中blockOperationWithBlock:方法中的操做也不是在当前线程（主线程）中执行的。从而印证了blockOperationWithBlock:中的操做也可能会在其余线程（非当前线程）中执行。

通常状况下，若是一个 NSBlockOperation 对象封装了多个操做。NSBlockOperation 是否开启新线程，取决于操做的个数。若是添加的操做的个数多，就会自动开启新线程。固然开启的线程数是由系统来决定的。

4.1.3 使用自定义继承自 NSOperation 的子类

若是使用子类 NSInvocationOperation、NSBlockOperation 不能知足平常需求，咱们可使用自定义继承自 NSOperation 的子类。能够经过重写 main 或者 start 方法来定义本身的 NSOperation 对象。重写main方法比较简单，咱们不须要管理操做的状态属性isExecuting 和 isFinished。当 main 执行完返回的时候，这个操做就结束了。

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

// YSCOperation.h 文件
#import <Foundation/Foundation.h>

@interface YSCOperation : NSOperation

@end

// YSCOperation.m 文件
#import "YSCOperation.h"

@implementation YSCOperation

- (void)main {
    if (!self.isCancelled) {
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2];
            NSLog(@"1---%@", [NSThread currentThread]);
        }
    }
}

@end
而后使用的时候导入头文件YSCOperation.h。

/** * 使用自定义继承自 NSOperation 的子类 */
- (void)useCustomOperation {
    // 1.建立 YSCOperation 对象
    YSCOperation *op = [[YSCOperation alloc] init];
    // 2.调用 start 方法开始执行操做
    [op start];
}
复制代码

输出结果：

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

下边咱们来说讲 NSOperationQueue 的建立。

4.2 建立队列

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

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

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

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

// 自定义队列建立方法
NSOperationQueue *queue = [[NSOperationQueue alloc] init];
复制代码

4.3 将操做加入到队列中

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

那么咱们须要将建立好的操做加入到队列中去。总共有两种方法：

1.- (void)addOperation:(NSOperation *)op;

须要先建立操做，再将建立好的操做加入到建立好的队列中去。

/**
 * 使用 addOperation: 将操做加入到操做队列中
 */
- (void)addOperationToQueue {

    // 1.建立队列
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];

    // 2.建立操做
    // 使用 NSInvocationOperation 建立操做1
    NSInvocationOperation *op1 = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(task1) object:nil];

    // 使用 NSInvocationOperation 建立操做2
    NSInvocationOperation *op2 = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(task2) object:nil];

    // 使用 NSBlockOperation 建立操做3
    NSBlockOperation *op3 = [NSBlockOperation blockOperationWithBlock:^{
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模拟耗时操做
            NSLog(@"3---%@", [NSThread currentThread]); // 打印当前线程
        }
    }];
    [op3 addExecutionBlock:^{
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模拟耗时操做
            NSLog(@"4---%@", [NSThread currentThread]); // 打印当前线程
        }
    }];

    // 3.使用 addOperation: 添加全部操做到队列中
    [queue addOperation:op1]; // [op1 start]
    [queue addOperation:op2]; // [op2 start]
    [queue addOperation:op3]; // [op3 start]
}
复制代码

输出结果：

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

2.- (void)addOperationWithBlock:(void (^)(void))block;

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

/**
 * 使用 addOperationWithBlock: 将操做加入到操做队列中
 */

- (void)addOperationWithBlockToQueue {
    // 1.建立队列
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];

    // 2.使用 addOperationWithBlock: 添加操做到队列中
    [queue addOperationWithBlock:^{
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模拟耗时操做
            NSLog(@"1---%@", [NSThread currentThread]); // 打印当前线程
        }
    }];
    [queue addOperationWithBlock:^{
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模拟耗时操做
            NSLog(@"2---%@", [NSThread currentThread]); // 打印当前线程
        }
    }];
    [queue addOperationWithBlock:^{
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模拟耗时操做
            NSLog(@"3---%@", [NSThread currentThread]); // 打印当前线程
        }
    }];
}
复制代码

输出结果：

能够看出：使用 addOperationWithBlock: 将操做加入到操做队列后可以开启新线程，进行并发执行。

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

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

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

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

最大并发操做数：maxConcurrentOperationCount
- maxConcurrentOperationCount 默认状况下为-1，表示不进行限制，可进行并发执行。
- maxConcurrentOperationCount 为1时，队列为串行队列。只能串行执行。
- maxConcurrentOperationCount大于1时，队列为并发队列。操做并发执行，固然这个值不该超过系统限制，即便本身设置一个很大的值，系统也会自动调整为 min{本身设定的值，系统设定的默认最大值}。

/**
 * 设置 MaxConcurrentOperationCount（最大并发操做数）
 */
- (void)setMaxConcurrentOperationCount {

    // 1.建立队列
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];

    // 2.设置最大并发操做数
    queue.maxConcurrentOperationCount = 1; // 串行队列
// queue.maxConcurrentOperationCount = 2; // 并发队列
// queue.maxConcurrentOperationCount = 8; // 并发队列

    // 3.添加操做
    [queue addOperationWithBlock:^{
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模拟耗时操做
            NSLog(@"1---%@", [NSThread currentThread]); // 打印当前线程
        }
    }];
    [queue addOperationWithBlock:^{
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模拟耗时操做
            NSLog(@"2---%@", [NSThread currentThread]); // 打印当前线程
        }
    }];
    [queue addOperationWithBlock:^{
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模拟耗时操做
            NSLog(@"3---%@", [NSThread currentThread]); // 打印当前线程
        }
    }];
    [queue addOperationWithBlock:^{
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模拟耗时操做
            NSLog(@"4---%@", [NSThread currentThread]); // 打印当前线程
        }
    }];
}
复制代码

最大并发操做数为1 输出结果：

最大并发操做数为2 输出结果：

能够看出：当最大并发操做数为1时，操做是按顺序串行执行的，而且一个操做完成以后，下一个操做才开始执行。当最大操做并发数为2时，操做是并发执行的，能够同时执行两个操做。而开启线程数量是由系统决定的，不须要咱们来管理。

这样看来，是否是比 GCD 还要简单了许多？

6. NSOperation 操做依赖

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

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

固然，咱们常常用到的仍是添加依赖操做。如今考虑这样的需求，好比说有 A、B 两个操做，其中 A 执行完操做，B 才能执行操做。

若是使用依赖来处理的话，那么就须要让操做 B 依赖于操做 A。具体代码以下：

/**
 * 操做依赖
 * 使用方法：addDependency:
 */
- (void)addDependency {

    // 1.建立队列
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];

    // 2.建立操做
    NSBlockOperation *op1 = [NSBlockOperation blockOperationWithBlock:^{
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模拟耗时操做
            NSLog(@"1---%@", [NSThread currentThread]); // 打印当前线程
        }
    }];
    NSBlockOperation *op2 = [NSBlockOperation blockOperationWithBlock:^{
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模拟耗时操做
            NSLog(@"2---%@", [NSThread currentThread]); // 打印当前线程
        }
    }];

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

    // 4.添加操做到队列中
    [queue addOperation:op1];
    [queue addOperation:op2];
}
复制代码

输出结果：

能够看到：经过添加操做依赖，不管运行几回，其结果都是 op1 先执行，op2 后执行。

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

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

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

8. 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]); // 打印当前线程
            }
        }];
    }];
}
复制代码

输出结果：

能够看到：经过线程间的通讯，先在其余线程中执行操做，等操做执行完了以后再回到主线程执行主线程的相应操做。

9. NSOperation、NSOperationQueue 线程同步和线程安全

线程安全：若是你的代码所在的进程中有多个线程在同时运行，而这些线程可能会同时运行这段代码。若是每次运行结果和单线程运行的结果是同样的，并且其余的变量的值也和预期的是同样的，就是线程安全的。若每一个线程中对全局变量、静态变量只有读操做，而无写操做，通常来讲，这个全局变量是线程安全的；如有多个线程同时执行写操做（更改变量），通常都须要考虑线程同步，不然的话就可能影响线程安全。
线程同步：可理解为线程 A 和线程 B 一块配合，A 执行到必定程度时要依靠线程 B 的某个结果，因而停下来，示意 B 运行；B 依言执行，再将结果给 A；A 再继续操做。

举个简单例子就是：两我的在一块儿聊天。两我的不能同时说话，避免听不清(操做冲突)。等一我的说完(一个线程结束操做)，另外一个再说(另外一个线程再开始操做)。

下面，咱们模拟火车票售卖的方式，实现 NSOperation 线程安全和解决线程同步问题。场景：总共有50张火车票，有两个售卖火车票的窗口，一个是北京火车票售卖窗口，另外一个是上海火车票售卖窗口。两个窗口同时售卖火车票，卖完为止。

9.1 NSOperation、NSOperationQueue 非线程安全

先来看看不考虑线程安全的代码：

/** * 非线程安全：不使用 NSLock * 初始化火车票数量、卖票窗口(非线程安全)、并开始卖票 */
- (void)initTicketStatusNotSave {
    NSLog(@"currentThread---%@",[NSThread currentThread]); // 打印当前线程

    self.ticketSurplusCount = 50;

    // 1.建立 queue1,queue1 表明北京火车票售卖窗口
    NSOperationQueue *queue1 = [[NSOperationQueue alloc] init];
    queue1.maxConcurrentOperationCount = 1;

    // 2.建立 queue2,queue2 表明上海火车票售卖窗口
    NSOperationQueue *queue2 = [[NSOperationQueue alloc] init];
    queue2.maxConcurrentOperationCount = 1;

    // 3.建立卖票操做 op1
    NSBlockOperation *op1 = [NSBlockOperation blockOperationWithBlock:^{
        [self saleTicketNotSafe];
    }];

    // 4.建立卖票操做 op2
    NSBlockOperation *op2 = [NSBlockOperation blockOperationWithBlock:^{
        [self saleTicketNotSafe];
    }];

    // 5.添加操做，开始卖票
    [queue1 addOperation:op1];
    [queue2 addOperation:op2];
}

/** * 售卖火车票(非线程安全) */
- (void)saleTicketNotSafe {
    while (1) {

        if (self.ticketSurplusCount > 0) {
            //若是还有票，继续售卖
            self.ticketSurplusCount--;
            NSLog(@"%@", [NSString stringWithFormat:@"剩余票数:%d 窗口:%@", self.ticketSurplusCount, [NSThread currentThread]]);
            [NSThread sleepForTimeInterval:0.2];
        } else {
            NSLog(@"全部火车票均已售完");
            break;
        }
    }
}
复制代码

输出结果：

省略一部分结果图。。。

能够看到：在不考虑线程安全，不使用 NSLock 状况下，获得票数是错乱的，这样显然不符合咱们的需求，因此咱们须要考虑线程安全问题。

9.2 NSOperation、NSOperationQueue 线程安全

线程安全解决方案：能够给线程加锁，在一个线程执行该操做的时候，不容许其余线程进行操做。iOS 实现线程加锁有不少种方式。@synchronized、 NSLock、NSRecursiveLock、NSCondition、NSConditionLock、pthread_mutex、dispatch_semaphore、OSSpinLock、atomic(property) set/get 等等各类方式。这里咱们使用 NSLock 对象来解决线程同步问题。NSLock 对象能够经过进入锁时调用 lock 方法，解锁时调用 unlock 方法来保证线程安全。

考虑线程安全的代码：

/**
 * 线程安全：使用 NSLock 加锁
 * 初始化火车票数量、卖票窗口(线程安全)、并开始卖票
 */

- (void)initTicketStatusSave {
    NSLog(@"currentThread---%@",[NSThread currentThread]); // 打印当前线程

    self.ticketSurplusCount = 50;

    self.lock = [[NSLock alloc] init];  // 初始化 NSLock 对象

    // 1.建立 queue1,queue1 表明北京火车票售卖窗口
    NSOperationQueue *queue1 = [[NSOperationQueue alloc] init];
    queue1.maxConcurrentOperationCount = 1;

    // 2.建立 queue2,queue2 表明上海火车票售卖窗口
    NSOperationQueue *queue2 = [[NSOperationQueue alloc] init];
    queue2.maxConcurrentOperationCount = 1;

    // 3.建立卖票操做 op1
    NSBlockOperation *op1 = [NSBlockOperation blockOperationWithBlock:^{
        [self saleTicketSafe];
    }];

    // 4.建立卖票操做 op2
    NSBlockOperation *op2 = [NSBlockOperation blockOperationWithBlock:^{
        [self saleTicketSafe];
    }];

    // 5.添加操做，开始卖票
    [queue1 addOperation:op1];
    [queue2 addOperation:op2];
}

/**
 * 售卖火车票(线程安全)
 */
- (void)saleTicketSafe {
    while (1) {

        // 加锁
        [self.lock lock];

        if (self.ticketSurplusCount > 0) {
            //若是还有票，继续售卖
            self.ticketSurplusCount--;
            NSLog(@"%@", [NSString stringWithFormat:@"剩余票数:%d 窗口:%@", self.ticketSurplusCount, [NSThread currentThread]]);
            [NSThread sleepForTimeInterval:0.2];
        }

        // 解锁
        [self.lock unlock];

        if (self.ticketSurplusCount <= 0) {
            NSLog(@"全部火车票均已售完");
            break;
        }
    }
}
复制代码

输出结果：

省略一部分结果图。。。

能够看出：在考虑了线程安全，使用 NSLock 加锁、解锁机制的状况下，获得的票数是正确的，没有出现混乱的状况。咱们也就解决了多个线程同步的问题。

10. NSOperation、NSOperationQueue 经常使用属性和方法概括

10.1 NSOperation 经常使用属性和方法

1.取消操做方法

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

2.判断操做状态方法

- (BOOL)isFinished; 判断操做是否已经结束。
- (BOOL)isCancelled; 判断操做是否已经标记为取消。
- (BOOL)isExecuting; 判断操做是否正在在运行。
- (BOOL)isReady; 判断操做是否处于准备就绪状态，这个值和操做的依赖关系相关。

3.操做同步

- (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; 在当前操做开始执行以前完成执行的全部操做对象数组。

10.2 NSOperationQueue 经常使用属性和方法

1.取消/暂停/恢复操做

- (void)cancelAllOperations; 能够取消队列的全部操做。
- (BOOL)isSuspended; 判断队列是否处于暂停状态。 YES 为暂停状态，NO 为恢复状态。
- (void)setSuspended:(BOOL)b; 可设置操做的暂停和恢复，YES 表明暂停队列，NO 表明恢复队列。

2.操做同步

- (void)waitUntilAllOperationsAreFinished; 阻塞当前线程，直到队列中的操做所有执行完毕。

3.添加/获取操做

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

4.获取队列

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

注意：

1.这里的暂停和取消（包括操做的取消和队列的取消）并不表明能够将当前的操做当即取消，而是当当前的操做执行完毕以后再也不执行新的操做。 2.暂停和取消的区别就在于：暂停操做以后还能够恢复操做，继续向下执行；而取消操做以后，全部的操做就清空了，没法再接着执行剩下的操做。

参考资料：

转自:行走的少年郎