op2

op2

关注
发信
关注(28)粉丝(399)

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 加锁、解锁机制的情况下，得到的票数是正确的，没有出现混乱的情况。我们也就解决了多个线程同步的问题。

05-02 15:05
Powered by LMLPHP ©2024 op2 0.075875