NSOperation、NSOperationQueue(II)

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

NSOperationQueue 创建的自定义队列同时具有串行、并发功能

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

最大并发操作数：maxConcurrentOperationCount

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

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

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

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

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

打印结果：

 <-------------------------NSOperationAndQueue 线程结束-------------------------->
 -- ::45.902770+ StruggleSwift[:] ---<NSThread: 0x60c000076e40>{number = , name = (null)}
 -- ::49.192405+ StruggleSwift[:] ---<NSThread: 0x60c000076e40>{number = , name = (null)}
 -- ::54.864788+ StruggleSwift[:] ---<NSThread: 0x60000007f200>{number = , name = (null)}
 -- ::56.866890+ StruggleSwift[:] ---<NSThread: 0x60000007f200>{number = , name = (null)}
 -- ::58.869083+ StruggleSwift[:] ---<NSThread: 0x60000007f200>{number = , name = (null)}
 -- ::00.874565+ StruggleSwift[:] ---<NSThread: 0x60000007f200>{number = , name = (null)}
 -- ::02.875308+ StruggleSwift[:] ---<NSThread: 0x60c000076e40>{number = , name = (null)}
 -- ::04.877348+ StruggleSwift[:] ---<NSThread: 0x60c000076e40>{number = , name = (null)}

结论：当最大并发操作数为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。具体代码如下：

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

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

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

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

     // 4.添加操作到队列中
     [queue addOperation:op1];
     [queue addOperation:op2];
 }

打印结果：

 <-------------------------NSOperationAndQueue 线程结束-------------------------->
 -- ::21.656997+ StruggleSwift[:] ---<NSThread: 0x60c0000777c0>{number = , name = (null)}
 -- ::24.756931+ StruggleSwift[:] ---<NSThread: 0x60c0000777c0>{number = , name = (null)}
 -- ::30.036394+ StruggleSwift[:] ---<NSThread: 0x60800007a9c0>{number = , name = (null)}
 -- ::33.012677+ StruggleSwift[:] ---<NSThread: 0x60800007a9c0>{number = , name = (null)}

NSOperation 优先级

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

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

上边我们说过：对于添加到队列中的操作，首先进入准备就绪的状态（就绪状态取决于操作之间的依赖关系），然后进入就绪状态的操作的开始执行顺序（非结束执行顺序）由操作之间相对的优先级决定（优先级是操作对象自身的属性）。

那么，什么样的操作才是进入就绪状态的操作呢？

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

举个例子，现在有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 属性的作用对象。

 a.queuePriority 属性决定了进入准备就绪状态下的操作之间的开始执行顺序。并且，优先级不能取代依赖关系。

b. 如果一个队列中既包含高优先级操作，又包含低优先级操作，并且两个操作都已经准备就绪，那么队列先执行高优先级操作。比如上例中，如果 op1 和 op4 是不同优先级的操作，那么就会先执行优先级高的操作。

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

NSOperation、NSOperationQueue 线程间的通信

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

 #pragma mark -  线程间通信
 - (void)communication {

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

     // 2.添加操作
     [queue addOperationWithBlock:^{
         // 异步进行耗时操作
         for (int i = ; i < ; i++) {
             [NSThread sleepForTimeInterval:]; // 模拟耗时操作
             NSLog(@"1---%@", [NSThread currentThread]); // 打印当前线程
         }

         // 回到主线程
         [[NSOperationQueue mainQueue] addOperationWithBlock:^{
             // 进行一些 UI 刷新等操作
             for (int i = ; i < ; i++) {
                 [NSThread sleepForTimeInterval:]; // 模拟耗时操作
                 NSLog(@"2---%@", [NSThread currentThread]); // 打印当前线程
             }
         }];
     }];
 }

打印结果：

<-------------------------NSOperationAndQueue 线程结束-------------------------->
-- ::11.278897+ StruggleSwift[:] ---<NSThread: 0x608000265d00>{number = , name = (null)}
-- ::17.168299+ StruggleSwift[:] ---<NSThread: 0x608000265d00>{number = , name = (null)}
-- ::28.123412+ StruggleSwift[:] ---<NSThread: 0x60400007bd40>{number = , name = main}
-- ::31.052426+ StruggleSwift[:] ---<NSThread: 0x60400007bd40>{number = , name = main}

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

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

线程安全：如果你的代码所在的进程中有多个线程在同时运行，而这些线程可能会同时运行这段代码。如果每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。
若每个线程中对全局变量、静态变量只有读操作，而无写操作，一般来说，这个全局变量是线程安全的；若有多个线程同时执行写操作（更改变量），一般都需要考虑线程同步，否则的话就可能影响线程安全。

线程同步：可理解为线程 A 和 线程 B 一块配合，A 执行到一定程度时要依靠线程 B 的某个结果，于是停下来，示意 B 运行；B 依言执行，再将结果给 A；A 再继续操作。

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

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

NSOperation、NSOperationQueue 非线程安全

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

     self.ticketSurplusCount = ;

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

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

     // 3.创建卖票操作 op1
     __weak typeof(self) weakSelf = self;
     NSBlockOperation *op1 = [NSBlockOperation blockOperationWithBlock:^{
         [weakSelf saleTicketNotSafe];
     }];

     // 4.创建卖票操作 op2
     NSBlockOperation *op2 = [NSBlockOperation blockOperationWithBlock:^{
         [weakSelf saleTicketNotSafe];
     }];

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

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

         if (self.ticketSurplusCount > ) {
             //如果还有票，继续售卖
             self.ticketSurplusCount--;
             NSLog(@"%@", [NSString stringWithFormat:@"剩余票数:%d 窗口:%@", self.ticketSurplusCount, [NSThread currentThread]]);
             [NSThread sleepForTimeInterval:0.2];
         } else {
             NSLog(@"所有火车票均已售完");
             break;
         }
     }
 }

打印结果：

 -- ::03.617873+ StruggleSwift[:] currentThread---<NSThread: 0x60800006b880>{number = , name = main}
 <-------------------------NSOperationAndQueue 线程结束-------------------------->
 -- ::19.360537+ StruggleSwift[:] 剩余票数: 窗口:<NSThread: 0x60c00007e740>{number = , name = (null)}
 -- ::19.360562+ StruggleSwift[:] 剩余票数: 窗口:<NSThread: 0x604000260d80>{number = , name = (null)}
 -- ::19.565970+ StruggleSwift[:] 剩余票数: 窗口:<NSThread: 0x604000260d80>{number = , name = (null)}
 -- ::19.565970+ StruggleSwift[:] 剩余票数: 窗口:<NSThread: 0x60c00007e740>{number = , name = (null)}
 -- ::19.767245+ StruggleSwift[:] 剩余票数: 窗口:<NSThread: 0x604000260d80>{number = , name = (null)}
 -- ::19.767245+ StruggleSwift[:] 剩余票数: 窗口:<NSThread: 0x60c00007e740>{number = , name = (null)}
 -- ::19.972287+ StruggleSwift[:] 剩余票数: 窗口:<NSThread: 0x604000260d80>{number = , name = (null)}
 -- ::19.972537+ StruggleSwift[:] 剩余票数: 窗口:<NSThread: 0x60c00007e740>{number = , name = (null)}
 -- ::20.175821+ StruggleSwift[:] 剩余票数: 窗口:<NSThread: 0x60c00007e740>{number = , name = (null)}
 -- ::20.175823+ StruggleSwift[:] 剩余票数: 窗口:<NSThread: 0x604000260d80>{number = , name = (null)}
 -- ::20.381388+ StruggleSwift[:] 剩余票数: 窗口:<NSThread: 0x604000260d80>{number = , name = (null)}
 -- ::20.381398+ StruggleSwift[:] 剩余票数: 窗口:<NSThread: 0x60c00007e740>{number = , name = (null)}
 -- ::20.587009+ StruggleSwift[:] 剩余票数: 窗口:<NSThread: 0x604000260d80>{number = , name = (null)}
 -- ::20.587009+ StruggleSwift[:] 剩余票数: 窗口:<NSThread: 0x60c00007e740>{number = , name = (null)}
 -- ::20.791763+ StruggleSwift[:] 所有火车票均已售完
 -- ::20.791763+ StruggleSwift[:] 所有火车票均已售完

结论：在不考虑线程安全，不使用 NSLock 情况下，得到票数是错乱的，这样显然不符合我们的需求，所以我们需要考虑线程安全问题

NSOperation、NSOperationQueue 线程安全

线程安全解决方案：可以给线程加锁，在一个线程执行该操作的时候，不允许其他线程进行操作。iOS 实现线程加锁有很多种方式。@synchronized、 NSLock、NSRecursiveLock、NSCondition、NSConditionLock、pthread_mutex、dispatch_semaphore、OSSpinLock、atomic(property) set/ge等等各种方式。这里我们使用 NSLock 对象来解决线程同步问题。NSLock 对象可以通过进入锁时调用 lock 方法，解锁时调用 unlock 方法来保证线程安全。

考虑线程安全的代码：

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

     self.ticketSurplusCount = ;

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

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

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

     // 3.创建卖票操作 op1
     __weak typeof(self) weakSelf = self;
     NSBlockOperation *op1 = [NSBlockOperation blockOperationWithBlock:^{
         [weakSelf saleTicketSafe];
     }];

     // 4.创建卖票操作 op2
     NSBlockOperation *op2 = [NSBlockOperation blockOperationWithBlock:^{
         [weakSelf saleTicketSafe];
     }];

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

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

         // 加锁
         [self.lock lock];

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

         // 解锁
         [self.lock unlock];

         if (self.ticketSurplusCount <= ) {
             NSLog(@"所有火车票均已售完");
             break;
         }
     }
 }

打印结果：

 -- ::16.070431+ StruggleSwift[:] currentThread---<NSThread: 0x60000006d880>{number = , name = main}
 (lldb) po self.lock
 <NSLock: 0x6040000b19a0>{name = nil}

 <-------------------------NSOperationAndQueue 线\\\213结束-------------------------->
 -- ::44.761455+ StruggleSwift[:] 剩余票数: 窗口:<NSThread: 0x604000269940>{number = , name = (null)}
 -- ::02.260390+ StruggleSwift[:] 剩余票数: 窗口:<NSThread: 0x60000046af00>{number = , name = (null)}
 -- ::10.237070+ StruggleSwift[:] 剩余票数: 窗口:<NSThread: 0x604000269940>{number = , name = (null)}
 -- ::10.442618+ StruggleSwift[:] 剩余票数: 窗口:<NSThread: 0x60000046af00>{number = , name = (null)}
 -- ::10.645708+ StruggleSwift[:] 剩余票数: 窗口:<NSThread: 0x604000269940>{number = , name = (null)}
 -- ::10.851185+ StruggleSwift[:] 剩余票数: 窗口:<NSThread: 0x60000046af00>{number = , name = (null)}
 -- ::11.056340+ StruggleSwift[:] 剩余票数: 窗口:<NSThread: 0x604000269940>{number = , name = (null)}
 -- ::11.259532+ StruggleSwift[:] 剩余票数: 窗口:<NSThread: 0x60000046af00>{number = , name = (null)}
 -- ::11.463973+ StruggleSwift[:] 剩余票数: 窗口:<NSThread: 0x604000269940>{number = , name = (null)}
 -- ::11.665998+ StruggleSwift[:] 剩余票数: 窗口:<NSThread: 0x60000046af00>{number = , name = (null)}
 -- ::11.870597+ StruggleSwift[:] 所有火车票均已售完
 -- ::11.870597+ StruggleSwift[:] 所有火车票均已售完

结论：考虑了线程安全，使用 NSLock 加锁、解锁机制的情况下，得到的票数是正确的，没有出现混乱的情况。我们也就解决了多个线程同步的问题。