前言

寒假期间学习过GCD。今天学习NSOperation。同样都是多线程封装，NSOperation和NSOperationQueue是基于GCD的更高一层的封装，完全的面向对象，相比于GCD复杂的各种API方法，它的优势就是更加的简单实用，代码的可读性更高。

NSOperation、NSOperationQueue 操作和操作队列

那么，GCD 中的一些概念同样适用于 NSOperation、NSOperationQueue。在 NSOperation、NSOperationQueue 中也有类似的任务（操作）和队列（操作队列）的概念。

操作（Operation）：
- 就是你在线程中执行的那段代码在这里插入代码片
- 在GCD时放在block里面的。在 NSOperation 中，我们使用 NSOperation 子类 NSInvocationOperation、NSBlockOperation，或者自定义子类来封装操作。
操作队列（Opertaion Queues)
- 这里的操作队列类似于操作系统里面的操作队列。是用来存放操作的队列，在GCD里面队列是FIFO的原则。NSOperationQueue对于在队列里的操作，有准备就绪状态，进入就绪状态的操作的开始执行顺序由NSOperationQueue提供的操作优先级决定。优先级是操作对象自身的属性
- NSOperationQueue有一个最大并发数的属性控制并发和串行。
- SOperationQueue 为我们提供了两种不同类型的队列：主队列和自定义队列。主队列运行在主线程之上，而自定义队列在后台执行

NSOperation、NSOperationQueue 的使用

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

NSOperation和NSOperationQueue实现多线程的具体步骤

先将需要执行的操作封装到一个NSOperation对象中
然后将NSOperation对象添加到NSOperationQueue中
将取出的NSOperation封装的操作放到一条新线程中执行
接下来系统会将操作队列NSOperationQueue的操作NSOperation取出来在新线程中执行操作

创建NSOperation（没有配合队列使用）

‼️NSOperation是个抽象类，并不具备封装操作的能力，必须使用他的子类。

使用NSOperation子类的方式有3种

1. NSInvocationOperation
2. NSBlockOperation
3.自定义类继承NSOperation,实现内部相应的方法

在不使用 NSOperationQueue，单独使用 NSOperation 的情况下是系统同步执行操作

第一种 NSInvocationOperation

第一个参数：目标对象 self
第二个参数：调用方法的名称
第三个参数：前面方法需要接受的参数 nil

创建操作，封装任务
启动执行操作

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

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

请添加图片描述

/**
 * 任务1
 */
- (void)task1 {
    for (int i = 0; i < 2; i++) {
        [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
        
       
        NSLog(@"1~~~%@", [NSThread currentThread]); // 打印当前线程
        
        ///可以看到：在没有使用 NSOperationQueue、在主线程中单独使用使用子类 NSInvocationOperation 执行一个操作的情况下，操作是在当前线程执行的，并没有开启新线程。
    }
}

打印[NSThread currentThread] 的结果将是当前线程的描述信息
打印的结果显示了当前线程的描述信息，其中包括线程对象的内存地址（0x123456789），线程的编号（number = 1）和线程的名称（name = Main）。
可以看到：在没有使用 NSOperationQueue、在主线程中单独使用使用子类 NSInvocationOperation 执行一个操作的情况下，操作是在当前线程执行的，并没有开启新线程。

第二种 NSBlockOperation

- (void)useBlockOperation {
    NSBlockOperation *blkOp1 = [NSBlockOperation blockOperationWithBlock:^{
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
            NSLog(@"1---%@", [NSThread currentThread]); // 打印当前线程
        }
    }];
        [blkOp1 start];
    /// 可以看到：在没有使用 NSOperationQueue、在主线程中单独使用 NSBlockOperation 执行一个操作的情况下，操作是在当前线程执行的，并没有开启新线程。

}

在没有使用 NSOperationQueue、在主线程中单独使用 NSBlockOperation 执行一个操作的情况下，操作是在当前线程执行的，并没有开启新线程。

addExecutionBlock

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];
    
    /**
  
     */
}

@end

请添加图片描述

可以看出：使用子类 NSBlockOperation，并调用方法 AddExecutionBlock: 的情况下，blockOperationWithBlock:方法中的操作和 addExecutionBlock: 中的操作是在不同的线程中异步执行的。而且，这次执行结果中 blockOperationWithBlock:方法中的操作也不是在当前线程（主线程）中执行的。从而印证了 blockOperationWithBlock: 中的操作也可能会在其他线程（非当前线程）中执行。
一般情况下，如果一个 NSBlockOperation 对象封装了多个操作。NSBlockOperation 是否开启新线程，取决于操作的个数。如果添加的操作的个数多，就会自动开启新线程。当然开启的线程数是由系统来决定的。

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

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

#import "TestOperation.h"

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

请添加图片描述

在 NSOperation 类中，isCancelled 是一个用于检查操作是否被取消的布尔属性。当你取消一个操作时，isCancelled 属性将被设置为 YES，表示操作已经被取消。

在 YSCOperation 类的 main 方法中，通过检查 isCancelled 属性，你可以判断操作是否已被取消。在示例中，如果操作没有被取消，就会执行一个简单的循环，并在每次循环中打印当前线程的信息。

在每次循环中，使用 [NSThread sleepForTimeInterval:] 方法使当前线程暂停2秒钟，然后打印线程信息。这样可以模拟一个耗时的任务。但在每次循环开始之前，会先检查 isCancelled 属性，以确保操作没有被取消。

通过使用 isCancelled 属性，我们可以在操作执行期间检查取消状态，以便在适当的时候终止操作的执行。这可以帮助你处理取消操作时的清理和逻辑控制。

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

创建操作队列NSOperationQueue

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

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

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

自定义队列：凡是添加到自定义队列的操作就会放到子线程执行，自定义队列同时包含了串行，并发功能

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

将操作加入到队列中

将创建好的操作加入到队列中去。总共有两种方法：

(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: 将操作加入到操作队列后能够开启新线程，进行并发执行。

- (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: 将操作加入到操作队列后能够开启新线程，进行并发执行

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

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

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

这里 maxConcurrentOperationCount 控制的不是并发线程的数量，而是一个队列中同时能并发执行的最大操作数。而且一个操作也并非只能在一个线程中运行。
最大并发操作数：maxConcurrentOperationCount
- maxConcurrentOperationCount 默认情况下为-1，表示不进行限制，可进行并发执行。
- maxConcurrentOperationCount 为1时，队列为串行队列。只能串行执行。
- maxConcurrentOperationCount 大于1时，队列为并发队列。操作并发执行，当然这个值不应超过系统限制，即使自己设置一个很大的值，系统也会自动调整为 min{自己设定的值，系统设定的默认最大值}。
问题记录为什么我在Xcode的command and tool开的文件没有打印结果在ViewController就有打印结果了？

起因是我在Xcode的command and tools 开的文件没有打印结果，直接结束程序了。

然后在某个demo的viewController里面打印请添加图片描述
发现就对了。。。

测试

只打印了一次线程就结束了。

正常流程

Maxcount = 1
请添加图片描述

Maxcount = 2或者更多
请添加图片描述
当最大并发操作数为1时，操作是按顺序串行执行的，并且一个操作完成之后，下一个操作才开始执行。当最大操作并发数为2时，操作是并发执行的，可以同时执行两个操作。而开启线程数量是由系统决定的，不需要我们来管理。

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。表示先执行A 再执行B

/**
 * 操作依赖
 * 使用方法：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];
}

请添加图片描述
通过实现依赖，我们可以确定执行先后顺序.

`@property (readonly, copy) NSArray<NSOperation > dependencies

@property (readonly, copy) NSArray<NSOperation *> *dependencies 是 NSOperation 类的一个属性，用于获取当前操作的所有依赖操作。
这个属性返回一个包含所有依赖操作的 NSArray 对象。NSArray 中的每个元素都是一个 NSOperation 对象，表示当前操作所依赖的操作。
你可以使用该属性来获取当前操作的所有依赖操作，并进一步操作这些依赖。例如，你可以遍历依赖数组，检查依赖操作的状态或执行其他操作。

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

NSOperation *operation1 = [NSBlockOperation blockOperationWithBlock:^{
    NSLog(@"Operation 1");
}];
NSOperation *operation2 = [NSBlockOperation blockOperationWithBlock:^{
    NSLog(@"Operation 2");
}];
NSOperation *operation3 = [NSBlockOperation blockOperationWithBlock:^{
    NSLog(@"Operation 3");
}];

[operation2 addDependency:operation1];
[operation3 addDependency:operation2];

[queue addOperations:@[operation1, operation2, operation3] waitUntilFinished:NO];

// 获取operation2的依赖操作
NSArray<NSOperation *> *dependencies = operation2.dependencies;

// 遍历依赖操作
for (NSOperation *dependency in dependencies) {
    // 执行操作，检查状态等
    NSLog(@"Dependency: %@", dependency);
}

在打印线程2的之前获取到了线程2的依赖也就是线程一。打印结果中显示了 operation1 的类和内存地址。
请添加图片描述

NSOperation 优先级

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

NSOperationQueuePriority 是一个枚举类型，用于定义操作队列的优先级。它有以下取值：

NSOperationQueuePriorityVeryLow：非常低优先级，值为 -8。
NSOperationQueuePriorityLow：低优先级，值为 -4。
NSOperationQueuePriorityNormal：普通优先级，值为 0。
NSOperationQueuePriorityHigh：高优先级，值为 4。
NSOperationQueuePriorityVeryHigh：非常高优先级，值为 8。

这些优先级的取值可以用来控制操作在队列中的执行顺序。优先级较高的操作会在优先级较低的操作之前执行，但并不能保证完全按照优先级顺序执行，因为还受到其他因素的影响，如操作的依赖关系、操作的状态等。

在 NSOperationQueue 中，可以使用以下方法来设置操作的优先级：

setQueuePriority:：用于设置单个操作的优先级。
setOperations:priority:：用于设置多个操作的优先级。
对于添加到队列中的操作，首先进入准备就绪的状态（就绪状态取决于操作之间的依赖关系），然后进入就绪状态的操作的开始执行顺序（非结束执行顺序）由操作之间相对的优先级决定（优先级是操作对象自身的属性）。

当一个操作的所有依赖都已经完成时，操作对象通常会进入准备就绪状态，等待执行。

举个例子，现在有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 是不同优先级的操作，那么就会先执行优先级高的操作。
如果一个队列中既包含了准备就绪状态的操作，又包含了未准备就绪的操作，未准备就绪的操作优先级比准备就绪的操作优先级高。那么，虽然准备就绪的操作优先级低，也会优先执行。优先级不能取代依赖关系。如果要控制操作间的启动顺序，则必须使用依赖关系。

NSOperation、NSOperationQueue 线程间的通信

和GCD一样，我们把需要耗费时间的放到其他线程，当完成之后回到主线程

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

请添加图片描述

线程安全

通常使用加锁的方式来保证线程的安全。

NSLock 是 Foundation 框架中提供的一种锁机制，用于保护多线程环境下的临界区（Critical Section）代码。通过使用 NSLock，可以确保在同一时间只有一个线程可以访问被锁定的代码块，从而避免数据竞争和线程冲突的问题。

// 创建 NSLock 对象
NSLock *lock = [[NSLock alloc] init];

// 在多线程环境下加锁和解锁
[lock lock];  // 加锁

// 执行需要保护的临界区代码

[lock unlock];  // 解锁

在上述示例中，我首先创建了一个 NSLock 对象 lock。然后，在多线程环境下，通过调用 [lock lock] 方法来加锁，这会阻塞其他线程直到该锁可用。在临界区代码执行完毕后，调用 [lock unlock] 方法来解锁，允许其他线程获取该锁并继续执行。

需要注意的是，加锁和解锁操作应该成对出现，以确保正确地保护临界区。在使用 NSLock 时，应遵循以下准则：

在需要保护的临界区代码前后使用 [lock lock] 和 [lock unlock] 进行加锁和解锁操作。
尽量保持临界区代码的执行时间尽量短，以减少锁的占用时间，提高多线程执行效率。
在使用 NSLock 进行加锁时，要确保所有访问共享资源的线程都使用了相同的 NSLock 对象。
使用 NSLock 可以有效地防止多线程环境下的数据竞争和线程冲突，提高应用程序的并发性和稳定性。

NSOperation 常用属性和方法

取消操作方法

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

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

多线程的比较

在这里插入图片描述

pthread

pthread跨平台，使用难度大，需要手动管理线程生命周期

GCD与NSOperation

GCD的执行效率更高，执行的是由Block构成的任务，是一个轻量级的数据结构，写起来更加方便
GCD只支持FIFO队列，NSOperation可以通过设置最大并发数、设置优先级、添加依赖关系来调整执行顺序
NSOperation可以跨越队列设置依赖关系，GCD仅仅能通过栅栏等方法才能控制执行顺序
NSOperation更加面向对象，支持KVO，也可以通过继承等关系添加子类。
所以如果我们需要考虑异步操作之间的顺序行、依赖关系，比如多线程并发下载等等，就使用NSOperation

GCD 与 NSThread 的区别

NSThread 通过 @selector 指定要执行的方法，代码分散, 依靠的是NSObject的分类实现的线程之间的通讯，如果要开线程必须创建多个线程对象。经常只用的是[NSTread current] 查看当前的线程。
NSThread是一个控制线程执行的对象，它不如NSOperation抽象，通过它我们可以方便的得到一个线程，并控制它。但NSThread的线程之间的并发控制，是需要我们自己来控制的，可以通过NSCondition实现。
GCD 通过 block 指定要执行的代码，代码集中, 所有的代码写在一起的，让代码更加简单，易于阅读和维护,不需要管理线程的创建/销毁/复用的过程！程序员不用关心线程的生命周期