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 = 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]); // 打印当前线程
        }
    }];
}

打印结果：

<-------------------------NSOperationAndQueue 线程结束-------------------------->
2018-03-31 16:14:45.902770+0800 StruggleSwift[14468:604379] 1---<NSThread: 0x60c000076e40>{number = 5, name = (null)}
2018-03-31 16:14:49.192405+0800 StruggleSwift[14468:604379] 1---<NSThread: 0x60c000076e40>{number = 5, name = (null)}
2018-03-31 16:14:54.864788+0800 StruggleSwift[14468:597389] 2---<NSThread: 0x60000007f200>{number = 3, name = (null)}
2018-03-31 16:14:56.866890+0800 StruggleSwift[14468:597389] 2---<NSThread: 0x60000007f200>{number = 3, name = (null)}
2018-03-31 16:14:58.869083+0800 StruggleSwift[14468:597389] 3---<NSThread: 0x60000007f200>{number = 3, name = (null)}
2018-03-31 16:15:00.874565+0800 StruggleSwift[14468:597389] 3---<NSThread: 0x60000007f200>{number = 3, name = (null)}
2018-03-31 16:15:02.875308+0800 StruggleSwift[14468:604379] 4---<NSThread: 0x60c000076e40>{number = 5, name = (null)}
2018-03-31 16:15:04.877348+0800 StruggleSwift[14468:604379] 4---<NSThread: 0x60c000076e40>{number = 5, 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 = 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];
}

打印结果：

<-------------------------NSOperationAndQueue 线程结束-------------------------->
2018-03-31 23:44:21.656997+0800 StruggleSwift[17855:844153] 1---<NSThread: 0x60c0000777c0>{number = 3, name = (null)}
2018-03-31 23:44:24.756931+0800 StruggleSwift[17855:844153] 1---<NSThread: 0x60c0000777c0>{number = 3, name = (null)}
2018-03-31 23:44:30.036394+0800 StruggleSwift[17855:875561] 2---<NSThread: 0x60800007a9c0>{number = 4, name = (null)}
2018-03-31 23:44:33.012677+0800 StruggleSwift[17855:875561] 2---<NSThread: 0x60800007a9c0>{number = 4, name = (null)}

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 属性的作用对象。

 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 = 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]); // 打印当前线程
            }
        }];
    }];
}

打印结果：

<-------------------------NSOperationAndQueue 线程结束-------------------------->
2018-04-01 08:57:11.278897+0800 StruggleSwift[824:13773] 1---<NSThread: 0x608000265d00>{number = 3, name = (null)}
2018-04-01 08:57:17.168299+0800 StruggleSwift[824:13773] 1---<NSThread: 0x608000265d00>{number = 3, name = (null)}
2018-04-01 08:57:28.123412+0800 StruggleSwift[824:13640] 2---<NSThread: 0x60400007bd40>{number = 1, name = main}
2018-04-01 08:57:31.052426+0800 StruggleSwift[824:13640] 2---<NSThread: 0x60400007bd40>{number = 1, 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 = 10;
    
    // 1.创建 queue1,queue1 代表北京火车票售卖窗口
    NSOperationQueue *queue1 = [[NSOperationQueue alloc] init];
    queue1.maxConcurrentOperationCount = 1;
    
    // 2.创建 queue2,queue2 代表上海火车票售卖窗口
    NSOperationQueue *queue2 = [[NSOperationQueue alloc] init];
    queue2.maxConcurrentOperationCount = 1;
    
    // 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 (1) {
        
        if (self.ticketSurplusCount > 0) {
            //如果还有票，继续售卖
            self.ticketSurplusCount--;
            NSLog(@"%@", [NSString stringWithFormat:@"剩余票数:%d 窗口:%@", self.ticketSurplusCount, [NSThread currentThread]]);
            [NSThread sleepForTimeInterval:0.2];
        } else {
            NSLog(@"所有火车票均已售完");
            break;
        }
    }
}

打印结果：

2018-04-01 09:13:03.617873+0800 StruggleSwift[1373:28962] currentThread---<NSThread: 0x60800006b880>{number = 1, name = main}
<-------------------------NSOperationAndQueue 线程结束-------------------------->
2018-04-01 09:13:19.360537+0800 StruggleSwift[1373:30935] 剩余票数:9 窗口:<NSThread: 0x60c00007e740>{number = 7, name = (null)}
2018-04-01 09:13:19.360562+0800 StruggleSwift[1373:31568] 剩余票数:8 窗口:<NSThread: 0x604000260d80>{number = 8, name = (null)}
2018-04-01 09:13:19.565970+0800 StruggleSwift[1373:31568] 剩余票数:7 窗口:<NSThread: 0x604000260d80>{number = 8, name = (null)}
2018-04-01 09:13:19.565970+0800 StruggleSwift[1373:30935] 剩余票数:7 窗口:<NSThread: 0x60c00007e740>{number = 7, name = (null)}
2018-04-01 09:13:19.767245+0800 StruggleSwift[1373:31568] 剩余票数:6 窗口:<NSThread: 0x604000260d80>{number = 8, name = (null)}
2018-04-01 09:13:19.767245+0800 StruggleSwift[1373:30935] 剩余票数:6 窗口:<NSThread: 0x60c00007e740>{number = 7, name = (null)}
2018-04-01 09:13:19.972287+0800 StruggleSwift[1373:31568] 剩余票数:5 窗口:<NSThread: 0x604000260d80>{number = 8, name = (null)}
2018-04-01 09:13:19.972537+0800 StruggleSwift[1373:30935] 剩余票数:4 窗口:<NSThread: 0x60c00007e740>{number = 7, name = (null)}
2018-04-01 09:13:20.175821+0800 StruggleSwift[1373:30935] 剩余票数:3 窗口:<NSThread: 0x60c00007e740>{number = 7, name = (null)}
2018-04-01 09:13:20.175823+0800 StruggleSwift[1373:31568] 剩余票数:3 窗口:<NSThread: 0x604000260d80>{number = 8, name = (null)}
2018-04-01 09:13:20.381388+0800 StruggleSwift[1373:31568] 剩余票数:2 窗口:<NSThread: 0x604000260d80>{number = 8, name = (null)}
2018-04-01 09:13:20.381398+0800 StruggleSwift[1373:30935] 剩余票数:1 窗口:<NSThread: 0x60c00007e740>{number = 7, name = (null)}
2018-04-01 09:13:20.587009+0800 StruggleSwift[1373:31568] 剩余票数:0 窗口:<NSThread: 0x604000260d80>{number = 8, name = (null)}
2018-04-01 09:13:20.587009+0800 StruggleSwift[1373:30935] 剩余票数:0 窗口:<NSThread: 0x60c00007e740>{number = 7, name = (null)}
2018-04-01 09:13:20.791763+0800 StruggleSwift[1373:31568] 所有火车票均已售完
2018-04-01 09:13:20.791763+0800 StruggleSwift[1373:30935] 所有火车票均已售完

 结论：在不考虑线程安全，不使用 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 = 10;
    
    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
    __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 (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;
        }
    }
}

打印结果：

2018-04-01 09:49:16.070431+0800 StruggleSwift[1941:58765] currentThread---<NSThread: 0x60000006d880>{number = 1, name = main}
(lldb) po self.lock
<NSLock: 0x6040000b19a0>{name = nil}

<-------------------------NSOperationAndQueue 线347250213结束-------------------------->
2018-04-01 09:49:44.761455+0800 StruggleSwift[1941:58823] 剩余票数:9 窗口:<NSThread: 0x604000269940>{number = 3, name = (null)}
2018-04-01 09:50:02.260390+0800 StruggleSwift[1941:59749] 剩余票数:8 窗口:<NSThread: 0x60000046af00>{number = 4, name = (null)}
2018-04-01 09:50:10.237070+0800 StruggleSwift[1941:58823] 剩余票数:7 窗口:<NSThread: 0x604000269940>{number = 3, name = (null)}
2018-04-01 09:50:10.442618+0800 StruggleSwift[1941:59749] 剩余票数:6 窗口:<NSThread: 0x60000046af00>{number = 4, name = (null)}
2018-04-01 09:50:10.645708+0800 StruggleSwift[1941:58823] 剩余票数:5 窗口:<NSThread: 0x604000269940>{number = 3, name = (null)}
2018-04-01 09:50:10.851185+0800 StruggleSwift[1941:59749] 剩余票数:4 窗口:<NSThread: 0x60000046af00>{number = 4, name = (null)}
2018-04-01 09:50:11.056340+0800 StruggleSwift[1941:58823] 剩余票数:3 窗口:<NSThread: 0x604000269940>{number = 3, name = (null)}
2018-04-01 09:50:11.259532+0800 StruggleSwift[1941:59749] 剩余票数:2 窗口:<NSThread: 0x60000046af00>{number = 4, name = (null)}
2018-04-01 09:50:11.463973+0800 StruggleSwift[1941:58823] 剩余票数:1 窗口:<NSThread: 0x604000269940>{number = 3, name = (null)}
2018-04-01 09:50:11.665998+0800 StruggleSwift[1941:59749] 剩余票数:0 窗口:<NSThread: 0x60000046af00>{number = 4, name = (null)}
2018-04-01 09:50:11.870597+0800 StruggleSwift[1941:58823] 所有火车票均已售完
2018-04-01 09:50:11.870597+0800 StruggleSwift[1941:59749] 所有火车票均已售完

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