//NSInvocationOperation NSBlockOperation
/**
操作队列（Operation Queues）：
这里的队列指操作队列，即用来存放操作的队列。不同于 GCD 中的调度队列 FIFO（先进先出）的原则。NSOperationQueue 对于添加到队列中的操作，首先进入准备就绪的状态（就绪状态取决于操作之间的依赖关系），然后进入就绪状态的操作的开始执行顺序（非结束执行顺序）由操作之间相对的优先级决定（优先级是操作对象自身的属性）。
操作队列通过设置最大并发操作数（maxConcurrentOperationCount）来控制并发、串行。
NSOperationQueue 为我们提供了两种不同类型的队列：主队列和自定义队列。主队列运行在主线程之上，而自定义队列在后台执行。
*/
/**
NSOperation 实现多线程的使用步骤分为三步：
创建操作：先将需要执行的操作封装到一个 NSOperation 对象中。
创建队列：创建 NSOperationQueue 对象。
将操作加入到队列中：将 NSOperation 对象添加到 NSOperationQueue 对象中。
之后呢，系统就会自动将 NSOperationQueue 中的 NSOperation 取出来，在新线程中执行操作。
*/
// //使用子类 NSInvocationOperation
// // 1.创建 NSInvocationOperation 对象
// NSInvocationOperation *op = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(task1) object:nil];
// // 2.调用 start 方法开始执行操作
// [op start];
// NSLog(@"2---%@", [NSThread currentThread]); // 打印当前线程
// // 1.创建 NSBlockOperation 对象
// NSBlockOperation *op = [NSBlockOperation blockOperationWithBlock:^{
// for (int i = 0; i < 2; i++) {
// [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
// NSLog(@"1---%@", [NSThread currentThread]); // 打印当前线程
// //在没有使用 NSOperationQueue、在主线程中单独使用 NSBlockOperation 执行一个操作的情况下，操作是在当前线程执行的，并没有开启新线程。
// }
// }];
// NSLog(@"2---%@", [NSThread currentThread]); // 打印当前线程
// // 2.调用 start 方法开始执行操作
// [op start];
// NSLog(@"3---%@", [NSThread currentThread]); // 打印当前线程
// /**
// * 使用子类 NSBlockOperation
// * 调用方法 AddExecutionBlock:
// */
// // 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];
/**
NSOperationQueue 的创建。
NSOperationQueue 一共有两种队列：主队列、自定义队列。其中自定义队列同时包含了串行、并发功能。下边是主队列、自定义队列的基本创建方法和特点。
1 主队列
- 凡是添加到主队列中的操作，都会放到主线程中执行（注：不包括操作使用addExecutionBlock:添加的额外操作，额外操作可能在其他线程执行，感谢指正）。
2 自定义队列（非主队列）
- 添加到这种队列中的操作，就会自动放到子线程中执行。
- 同时包含了：串行、并发功能。
*/
// /**
// 使用 NSOperation 子类创建操作，并使用 addOperation: 将操作加入到操作队列后能够开启新线程，进行并发执行。
// */
// // 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]
// /**
// 无需先创建操作，在 block 中添加操作，直接将包含操作的 block 加入到队列中。
// 使用 addOperationWithBlock: 将操作加入到操作队列后能够开启新线程，进行并发执行。
// */
// // 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]); // 打印当前线程
// }
// }];
// [queue addOperationWithBlock:^{
// for (int i = 0; i < 2; i++) {
// [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
// NSLog(@"4---%@", [NSThread currentThread]); // 打印当前线程
// }
// }];
/**
NSOperationQueue 控制串行执行、并发执行
NSOperationQueue 创建的自定义队列同时具有串行、并发功能，上边我们演示了并发功能，那么他的串行功能是如何实现的？
这里有个关键属性 maxConcurrentOperationCount，叫做最大并发操作数。用来控制一个特定队列中可以有多少个操作同时参与并发执行。
注意：这里 maxConcurrentOperationCount 控制的不是并发线程的数量，而是一个队列中同时能并发执行的最大操作数。而且一个操作也并非只能在一个线程中运行。
maxConcurrentOperationCount 默认情况下为-1，表示不进行限制，可进行并发执行。
maxConcurrentOperationCount 为1时，队列为串行队列。只能串行执行。
maxConcurrentOperationCount 大于1时，队列为并发队列。操作并发执行，当然这个值不应超过系统限制，即使自己设置一个很大的值，系统也会自动调整为 min{自己设定的值，系统设定的默认最大值}。
*/
/**
设置 MaxConcurrentOperationCount（最大并发操作数）
*/
// // 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]); // 打印当前线程
// }
// }];
// [queue addOperationWithBlock:^{
// for (int i = 0; i < 2; i++) {
// [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
// NSLog(@"5---%@", [NSThread currentThread]); // 打印当前线程
// }
// }];
/**
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 才能执行操作。
*/
/**
操作依赖
使用方法：addDependency:
操作结果： 通过添加操作依赖，无论运行几次，其结果都是 op1 先执行，op2 后执行。
*/
// //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];
//
// //4 添加操作到队列中
// [queue addOperation:op1];
// [queue addOperation: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 都不是准备就绪状态下的操作。
*/
/**
NSOperation、NSOperationQueue 线程间的通信在 iOS 开发过程中，我们一般在主线程里边进行 UI 刷新，例如：点击、滚动、拖拽等事件。我们通常把一些耗时的操作放在其他线程，比如说图片下载、文件上传等耗时操作。而当我们有时候在其他线程完成了耗时操作时，需要回到主线程，那么就用到了线程之间的通讯。
*/
/**
线程间通信
通过线程间的通信，先在其他线程中执行操作，等操作执行完了之后再回到主线程执行主线程的相应操作。
*/
// //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 刷新等操作
// NSLog(@"2---%@", [NSThread currentThread]); // 打印当前线程
// }];
// }];
/**
NSOperation、NSOperationQueue 线程同步和线程安全
线程安全：如果你的代码所在的进程中有多个线程在同时运行，而这些线程可能会同时运行这段代码。如果每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。
若每个线程中对全局变量、静态变量只有读操作，而无写操作，一般来说，这个全局变量是线程安全的；若有多个线程同时执行写操作（更改变量），一般都需要考虑线程同步，否则的话就可能影响线程安全。
线程同步：可理解为线程 A 和 线程 B 一块配合，A 执行到一定程度时要依靠线程 B 的某个结果，于是停下来，示意 B 运行；B 依言执行，再将结果给 A；A 再继续操作。
*/
/**
下面，我们模拟火车票售卖的方式，实现 NSOperation 线程安全和解决线程同步问题。
场景：总共有50张火车票，有两个售卖火车票的窗口，一个是北京火车票售卖窗口，另一个是上海火车票售卖窗口。两个窗口同时售卖火车票，卖完为止。
*/
/**先来看看不考虑线程安全的代码：*/
// self.ticketSurplusCount = 50;
//
// // 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 saleTicketNotSafe];
// }];
//
// // 4.创建卖票操作 op2
// NSBlockOperation *op2 = [NSBlockOperation blockOperationWithBlock:^{
// [self saleTicketNotSafe];
// }];
//
// // 5.添加操作，开始卖票
// [queue1 addOperation:op1];
// [queue2 addOperation:op2];
/**
NSOperation、NSOperationQueue 线程安全
线程安全解决方案：可以给线程加锁，在一个线程执行该操作的时候，不允许其他线程进行操作。iOS 实现线程加锁有很多种方式。@synchronized、 NSLock、NSRecursiveLock、NSCondition、NSConditionLock、pthread_mutex、dispatch_semaphore、OSSpinLock、atomic(property) set/ge等等各种方式。这里我们使用 NSLock 对象来解决线程同步问题。NSLock 对象可以通过进入锁时调用 lock 方法，解锁时调用 unlock 方法来保证线程安全。
*/
// 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];
// // 1.创建队列
// NSOperationQueue *queue = [[NSOperationQueue alloc] init];
//
// // 2.设置最大并发操作数
//// queue.maxConcurrentOperationCount = -1; // 并行队列
//
// // 3.添加操作
// NSBlockOperation *op1 = [NSBlockOperation blockOperationWithBlock:^{
// NSLog(@"op1 start");
// dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
// NSLog(@"1---%@", [NSThread currentThread]); // 打印当前线程
// });
// NSLog(@"op1 end");
// }];
// NSBlockOperation *op2 = [NSBlockOperation blockOperationWithBlock:^{
// NSLog(@"op2 start");
// dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
// NSLog(@"2---%@", [NSThread currentThread]); // 打印当前线程
// });
// NSLog(@"op2 end");
// }];
// NSBlockOperation *op3 = [NSBlockOperation blockOperationWithBlock:^{
// [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
// NSLog(@"3---%@", [NSThread currentThread]); // 打印当前线程
// }];
// NSBlockOperation *op4 = [NSBlockOperation blockOperationWithBlock:^{
// [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
// NSLog(@"4---%@", [NSThread currentThread]); // 打印当前线程
// }];
// NSBlockOperation *op5 = [NSBlockOperation blockOperationWithBlock:^{
// [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
// NSLog(@"5---%@", [NSThread currentThread]); // 打印当前线程
// }];
//
// [op2 addDependency:op1];
// //
// [queue addOperations:@[op1] waitUntilFinished:true];
// [queue addOperations:@[op2] waitUntilFinished:true];
// [queue addOperation:op3];
// [queue addOperation:op4];
// [queue addOperation:op5];
// [op1 waitUntilFinished];
//
// [op3 cancel];
iOS中的NSOperation和NSOperationQueue
©著作权归作者所有,转载或内容合作请联系作者
【社区内容提示】社区部分内容疑似由AI辅助生成，浏览时请结合常识与多方信息审慎甄别。
平台声明：文章内容（如有图片或视频亦包括在内）由作者上传并发布，文章内容仅代表作者本人观点，简书系信息发布平台，仅提供信息存储服务。
【社区内容提示】社区部分内容疑似由AI辅助生成，浏览时请结合常识与多方信息审慎甄别。
平台声明：文章内容（如有图片或视频亦包括在内）由作者上传并发布，文章内容仅代表作者本人观点，简书系信息发布平台，仅提供信息存储服务。
