NSOperation && NSOperationQueue

## 简介

* [NSOperation 、 NSOperationQueue](https://developer.apple.com/library/archive/documentation/General/Conceptual/ConcurrencyProgrammingGuide/OperationObjects/OperationObjects.html) 是基于 GCD 更高一层的封装，完全面向对象。更简单易用,可读性更高

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

## 操作(Operation)、 操作队列(Operation Queues)
* 操作 
    * 就是在线程中执行的那段代码
    * GCD 是放在 block 中。在 NSOperation 中 使用 NSOperation 子类 `NSInvocationOperation`、`NSBlockOperation`，或者`自定义子类`来封装操作 

* 操作队列
    * 存放操作的队列
    * 不同于 GCD 中的调度队列 FIFO（先进先出）的原则。`NSOperationQueue` 对于添加到队列中的操作，首先进入准备就绪的状态（就绪状态取决于操作之间的依赖关系），然后进入就绪状态的操作的开始执行顺序（非结束执行顺序）由操作之间相对的优先级决定（优先级是操作对象自身的属性） 
    * 操作队列通过设置最大并发操作数`maxConcurrentOperationCount`来控制并发、串行
    * 提供了两种不同类型的队列：`主队列`和`自定义队列`。主队列运行在主线程之上，而自定义队列在后台执行

## 使用步骤
* 创建操作：需要执行的操作封装到一个 NSOperation 中
* 创建队列：创建 NSOperationQueue 队列
* 将操作加入到队列：将 NSOperation 对象添加到 NSOperationQueue 对象中
* 然后系统会自动从 NSOperationQueue 中取出 NSOperation 在子线程中执行

## 基本使用
### 封装操作（三种方式）
NSOperation 是抽象类，只能使用子类来封装操作：
* 使用子类 NSInvocationOperation
* 使用子类 NSBlockOperation
* 自定义继承自 NSOperation 的子类，通过内部相应的方法封装操作

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

#### 使用子类 NSInvocationOperation

```
- (void)viewDidLoad {
    [super viewDidLoad];
    
    // 在主线程调用
    [self NSInvocationOperationTest];
    // 在子线程调用
    [NSThread detachNewThreadSelector:@selector(NSInvocationOperationTest) toTarget:self withObject:nil];
}

- (void)NSInvocationOperationTest{
    // 1.创建 NSInvocationOperation 对象
    NSInvocationOperation *operation = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(task) object:nil];
    //2.调用 start 方法开始执行操作
    [operation start];
}

- (void)task {
    for (int i = 0 ; i < 5; i ++) {
        [NSThread sleepForTimeInterval:2.0]; // 模拟耗时
        NSLog(@"currentThread == %@",[NSThread currentThread]);
    }
}
@end
```

```
// 执行结果
currentThread == <NSThread: 0x600001ea1b80>{number = 1, name = main}
currentThread == <NSThread: 0x600001ea1b80>{number = 1, name = main}
currentThread == <NSThread: 0x600001ea1b80>{number = 1, name = main}
currentThread == <NSThread: 0x600001ea1b80>{number = 1, name = main}
currentThread == <NSThread: 0x600001ea1b80>{number = 1, name = main}
currentThread == <NSThread: 0x600001e29ec0>{number = 7, name = (null)}
currentThread == <NSThread: 0x600001e29ec0>{number = 7, name = (null)}
currentThread == <NSThread: 0x600001e29ec0>{number = 7, name = (null)}
currentThread == <NSThread: 0x600001e29ec0>{number = 7, name = (null)}
currentThread == <NSThread: 0x600001e29ec0>{number = 7, name = (null)}
```

在没有使用 NSOperationQueue 的情况下：
* 在主线程执行操作，操作就在当前线程执行，没有开启新线程
* 在其他线程执行操作，操作就在当前线程执行，并没有开启新的线程

#### 使用子类 NSBlockOperation

```
- (void)viewDidLoad {
    [super viewDidLoad];
    
    // 在主线程调用
    [self NSBlockOperationTest];
    // 在子线程调用
    [NSThread detachNewThreadSelector:@selector(NSBlockOperationTest) toTarget:self withObject:nil];
}

- (void)NSBlockOperationTest{
    // 1、创建 NSBlockOperation 对象
    NSBlockOperation *operation = [NSBlockOperation blockOperationWithBlock:^{
        for (int i = 0 ; i < 5; i ++) {
            [NSThread sleepForTimeInterval:2.0]; // 模拟耗时
            NSLog(@"currentThread == %@",[NSThread currentThread]);
        }
    }];
    
    //2、调用 start 方法开始执行操作
    [operation start];
}
```

```
currentThread == <NSThread: 0x6000037760c0>{number = 1, name = main}
currentThread == <NSThread: 0x6000037760c0>{number = 1, name = main}
currentThread == <NSThread: 0x6000037760c0>{number = 1, name = main}
currentThread == <NSThread: 0x6000037760c0>{number = 1, name = main}
currentThread == <NSThread: 0x6000037760c0>{number = 1, name = main}
currentThread == <NSThread: 0x6000037f0980>{number = 7, name = (null)}
currentThread == <NSThread: 0x6000037f0980>{number = 7, name = (null)}
currentThread == <NSThread: 0x6000037f0980>{number = 7, name = (null)}
currentThread == <NSThread: 0x6000037f0980>{number = 7, name = (null)}
currentThread == <NSThread: 0x6000037f0980>{number = 7, name = (null)}
```

和上边 NSInvocationOperation 使用一样。因为代码是在主线程中调用的，所以打印结果为主线程。如果在其他线程中执行操作，则打印结果为其他线程

* NSBlockOperation 还提供了一个方法 addExecutionBlock: 使用子类 NSBlockOperation，并调用方法 AddExecutionBlock: 的情况下，blockOperationWithBlock:方法中的操作 和 addExecutionBlock: 中的操作是在不同的线程中异步执行的。而且，执行结果中 blockOperationWithBlock:方法中的操作也不是在当前线程（主线程）中执行的。从而印证了blockOperationWithBlock: 中的操作也可能会在其他线程（非当前线程）中执行。

```
- (void)viewDidLoad {
    [super viewDidLoad];
    
    // 在主线程调用
    [self NSBlockOperationTest];
    // 在子线程调用
    [NSThread detachNewThreadSelector:@selector(NSBlockOperationTest) toTarget:self withObject:nil];
}

- (void)NSBlockOperationTest{
    // 1、创建 NSBlockOperation 对象
    NSBlockOperation *operation = [NSBlockOperation blockOperationWithBlock:^{
        for (int i = 0 ; i < 5; i ++) {
            [NSThread sleepForTimeInterval:2.0]; // 模拟耗时
            NSLog(@"currentThread == %@",[NSThread currentThread]);
        }
    }];
    
    [operation addExecutionBlock:^{
        for (int i = 0 ; i < 5; i ++) {
                   [NSThread sleepForTimeInterval:2.0]; // 模拟耗时
                   NSLog(@"currentThread =1111= %@",[NSThread currentThread]);
               }
    }];
    [operation addExecutionBlock:^{
        for (int i = 0 ; i < 5; i ++) {
                   [NSThread sleepForTimeInterval:2.0]; // 模拟耗时
                   NSLog(@"currentThread =2222= %@",[NSThread currentThread]);
               }
    }];
    [operation addExecutionBlock:^{
           for (int i = 0 ; i < 5; i ++) {
                      [NSThread sleepForTimeInterval:2.0]; // 模拟耗时
                      NSLog(@"currentThread =3333= %@",[NSThread currentThread]);
                  }
       }];
    //2、调用 start 方法开始执行操作
    [operation start];
}
```


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

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

* 方法的重写

```
// 对于并发的Operation需要重写
- (void)start;

// 非并发的Operation需要重写
- (void)main;
```

* 属性的重写

```
// 任务是否取消（只读） 自定义子类，需重写该属性
@property (readonly, getter=isCancelled) BOOL cancelled;

// 可取消操作，实质是标记 isCancelled 状态，自定义子类，需利用该方法标记取消状态
- (void)cancel;

// 任务是否正在执行（只读），自定义子类，需重写该属性
@property (readonly, getter=isExecuting) BOOL executing;

// 任务是否结束（只读），自定义子类，需重写该属性
// 如果为YES，则队列会将任务移除队列
@property (readonly, getter=isFinished) BOOL finished;

// 判断任务是否为并发（只读），默认返回NO
// 自定义子类，需重写getter方法，并返回YES
@property (readonly, getter=isAsynchronous) BOOL asynchronous;

// 任务是否准备就绪（只读）
// 对于加入队列的任务来说，ready为YES，则表示该任务即将开始执行
// 如果存在依赖关系的任务没有执行完，则ready为NO
@property (readonly, getter=isReady) BOOL ready;

``` 

##### 非并发的 NSOperation 子类 
非并发任务，直接将需要的任务放在 main 方法中，然后直接调用即可。这样直接调用main方法会存在一个问题，由于没有实现finished属性，所以获取finished属性时，只会返回NO，而且任务加入到队列后，不会被删除，另外任务执行完后，回调也不会被执行，所以最好不要只实现一个main方法来使用。
而且，其实也没有必要使用这种非并发的NSOperation子类，实在想不出有什么场景需要来用它

##### 并发的 NSOperation 子类
需要重写一下几个方法和属性：
* **start：**把需要执行的任务放在start方法里，任务加到队列后，队列会管理任务并在线程被调度后，调用start方法，不需要调用父类的方法
* **asynchronous：**表示是否并发执行
* **executing：**表示任务是否正在执行，需要手动调用KVO方法来进行通知，方便其他类监听了任务的该属性
* **finished：**表示任务是否结束，需要手动调用KVO方法来进行通知，队列也需要监听改属性的值，用于判断任务是否结束

```
#pragma mark - 自定义 NSOperation
@interface MyOperation : NSOperation

@property (nonatomic,assign,getter=isExecuting) BOOL executing;
@property (nonatomic,assign,getter=isFinished)  BOOL finished;

@end
/*
* 自定义并发的NSOperation需要以下步骤：
* 1.start方法：该方法必须实现，
* 2.main:该方法可选，如果你在start方法中定义了你的任务，则这个方法就可以不实现，但通常为了代码逻辑清晰，通常会在该方法中定义自己的任务
* 3.isExecuting  isFinished 主要作用是在线程状态改变时，产生适当的KVO通知
* 4.isConcurrent(isAsynchronous) :必须覆盖并返回YES;
*/

#import "MyOperation.h"

@implementation MyOperation

// 由于父类是 readonly 的，所需重载时需要setter的话需要手动合成
@synthesize executing = _executing;
@synthesize finished = _finished;

- (instancetype)init {
    if (self = [super init]) {
        _executing = NO;
        _finished = NO;
    }
    return self;
}

/*
 并发操作必须重载此方法，并使用自定义的实现替换默认实现
 重载 start 方法负责以异步的方式启动一个操作，无论是像开启一个线程还是调用异步函数，都可以在start 方法中进行
 开始操作之前需要需要更新操作的执行状态，方便查看操作状态
 任何时候都不需要调用父类的 start 方法
 
 main 方法可选，如果在 start 方法中定义了任务，mian 方法就可以不实现
 通常为了代码清晰，会在该方法中定义自己的任务
 */
// 此方法必须实现
- (void)start {
    @autoreleasepool {
        if (self.isCancelled) {
            self.finished = YES;
            self.executing = NO;
            return;
        }
        
        self.executing = YES;
        
        // 需要做的任务 ......
        for (int i = 0; i < 10; i ++) {
            [NSThread sleepForTimeInterval:2];
            NSLog(@"Thread1 == %@",[NSThread currentThread]);
        }
        
        for (int i = 0; i < 10; i ++) {
            [NSThread sleepForTimeInterval:2];
            NSLog(@"Thread2 == %@",[NSThread currentThread]);
        }
    }
    
    // 任务执行完，手动设置状态
    self.finished = YES;
    self.executing = NO;
}

#pragma mark - getter & setter

- (void)setExecuting:(BOOL)executing {
    [self willChangeValueForKey:@"isExecuting"];
    _executing = executing;
    [self didChangeValueForKey:@"isExecuting"];
}

- (BOOL)isExecuting {
    return _executing;
}

- (void)setFinished:(BOOL)finished {
    [self willChangeValueForKey:@"isFinished"];
    _finished = finished;
    [self didChangeValueForKey:@"isFinished"];
}

- (BOOL)isFinished {
    return _finished;
}

#pragma mark - 标识是否并发
- (BOOL)isAsynchronous {
    return  YES;
}

//- (void)cancel {
//    if (self.isFinished) return;
//    [super cancel];
//
//    self.executing = NO;
//    self.finished = YES;
//}
```

### 创建队列 
NSOperationQueue 一共有两种队列：
* 主队列
* 自定义队列。自定义队列包含串行、并发

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

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

#### 自定义队列

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

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

### 将操作放到队列中

将操作放到队列的方式一共有2种：
* - (void)addOperation:(NSOperation *)op:
* - (void)addOperationWithBlock:(void (\^)(void))block;

#### - (void)addOperation:(NSOperation *)op:
* 需要先创建操作，再将创建好的操作加入到创建好的队列中去 

```
///  使用 addOperation: 将操作加入到操作队列中
- (void)addOperationToQueue {
    // 1.创建队列
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];

    // 2.创建操作
    // 使用 NSInvocationOperation 创建操作1
    NSInvocationOperation *op1 = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(task) 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 控制串行执行、并发执行

最大并发操作数 **maxConcurrentOperationCount** ，用来控制一个特定队列中可以有多少个操作同时参与并发执行。
>**maxConcurrentOperationCount** 不是并发线程的数量，而是一个队列中同时能并发执行的最大操作数。而且一个操作也并非只能在一个线程中运行

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

```
- (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：
 最大并发操作数8：
 

 * 当最大并发操作数为1时，**操作是按顺序串行执行的，并且一个操作完成之后，下一个操作才开始执行**。
 * 当最大操作并发数为2时，**操作是并发执行的，可以同时执行两个操作**。而**开启线程数量是由系统决定**的，不需要我们来管理   

### NSOperation 操作依赖
NSOperation、NSOperationQueue 最吸引人的地方是它能添加操作之间的依赖关系。通过操作依赖，我们可以很方便的控制操作之间的执行先后顺序；
* - (void)addDependency:(NSOperation *)op; 添加依赖，使当前操作依赖于操作 op 的完成。
* - (void)removeDependency:(NSOperation *)op; 移除依赖，取消当前操作对操作 op 的依赖。
* @property (readonly, copy) NSArray<NSOperation *> *dependencies; 在当前操作开始执行之前完成执行的所有操作对象数组。

```
有 A、B 两个操作，其中 A 执行完操作，B 才能执行操作
- (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 后执行

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

### 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]); // 打印当前线程
            }
        }];
    }];
}
```
* 通过线程间的通信，先在其他线程中执行操作，等操作执行完了之后再回到主线程执行主线程的相应操作

### NSOperation、NSOperationQueue 线程安全

线程安全解决方案：可以给线程加锁，在一个线程执行该操作的时候，不允许其他线程进行操作。iOS 实现线程加锁有很多种方式。@synchronized、 NSLock、NSRecursiveLock、NSCondition、NSConditionLock、pthread_mutex、dispatch_semaphore、OSSpinLock、atomic(property) set/ge等等各种方式

```
/**
 * 线程安全：使用 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;
        }
    }
}
```

### NSOperation、NSOperationQueue 常用属性和方法
####  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)addOperationWithBlock:(void (^)(void))block; 向队列中添加一个 NSBlockOperation 类型操作对象。
    * - (void)addOperations:(NSArray *)ops waitUntilFinished:(BOOL)wait; 向队列中添加操作数组，wait 标志是否阻塞当前线程直到所有操作结束
    * - (NSArray *)operations; 当前在队列中的操作数组（某个操作执行结束后会自动从这个数组清除）。
    * - (NSUInteger)operationCount; 当前队列中的操作数。
* 获取队列
    * + (id)currentQueue; 获取当前队列，如果当前线程不是在 NSOperationQueue 上运行则返回 nil。
    * + (id)mainQueue; 获取主队列。

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

[『NSOperation、NSOperationQueue』详尽总结](https://www.jianshu.com/p/4b1d77054b35)

[苹果官方——并发编程指南：Operation Queues](https://developer.apple.com/library/archive/documentation/General/Conceptual/ConcurrencyProgrammingGuide/OperationObjects/OperationObjects.html)

[苹果官方文档：NSOperation](https://developer.apple.com/documentation/foundation/nsoperation?language=occ)

[Objc 中国：并发编程：API 及挑战](https://objccn.io/issue-2-1/)
    
其他多线程相关：
[iOS 多线程：『pthread、NSThread』详尽总结](https://www.jianshu.com/p/cbaeea5368b1)
[iOS 多线程：『GCD』详尽总结](https://www.jianshu.com/p/2d57c72016c6)