【iOS】NSOperation、NSOperationQueue

文章目录

前言
一、NSOperation、NSOperationQueue 简介
二、NSOperation、NSOperationQueue 操作和操作队列
三、NSOperation
四、NSOperationQueue
五、NSOperationQueue 控制串行执行、并发执行
六、 NSOperation 操作依赖
七、NSOperation 优先级
八、NSOperation、NSOperationQueue 线程间的通信
九、NSOperation、NSOperationQueue 线程同步和线程安全
- NSOperation、NSOperationQueue 非线程安全
- NSOperation、NSOperationQueue 非线程安全
十、NSOperation、NSOperationQueue 常用属性和方法归纳
- NSOperation 常用属性和方法
- NSOperationQueue 常用属性和方法

前言

寒假学习了GCD，前几天学习了NSThread，今天来学习iOS 多线程中 NSOperation、NSOperationQueue 的相关知识以及使用方法。

一、NSOperation、NSOperationQueue 简介

NSOperation、NSOperationQueue 是苹果提供给我们的一套多线程解决方案。
实际上 NSOperation、NSOperationQueue 是基于 GCD 更高一层的封装，完全面向对象。但是比 GCD 更简单易用、代码可读性也更高。

NSOperation需要配合NSOperationQueue来实现多线程。

二、NSOperation、NSOperationQueue 操作和操作队列

由于NSOperation、NSOperationQueue 是GCD的更高级的封装，因此两者有一些相同的概念

操作（Operation）
执行操作，也就相当于我们在线程中执行的代码
在GCD操作是放在Block中的，在 NSOperation 中，我们使用 NSOperation 子类 NSInvocationOperation、NSBlockOperation，或者自定义子类来封装操作。
操作队列（Operation Queues）
这里的队列是指操作队列，即用来存放操作的队列。不同于GCD的先进先出，NSOperationQueue可以设置操作执行的优先级
操作队列通过设置最大并发操作数（maxConcurrentOperationCount） 来控制并发、串行。
NSOperationQueue 为我们提供了两种不同类型的队列：主队列和自定义队列。主队列运行在主线程之上，而自定义队列在后台执行。

三、NSOperation

NSOperatino实现多线程的步骤如下：

1、创建任务：先将需要执行的操作封装到NSOperation对象中。
2、创建队列：创建NSOperationQueue。
3、将任务加入到队列中：将NSOperation对象添加到NSOperationQueue中

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

- (void)applicationDidFinishLaunching:(UIApplication *)application {
    MyOperation *operation = [[MyOperation alloc] init];
    NSLog(@"Before operation start");
    [operation start];
    NSLog(@"After operation finish");
}

操作从开始到结束的输出都是按顺序且同步的。应用的执行将在 Before operation start 打印后直接开始 NSOperation，然后直到该操作完成后，才继续执行打印 After operation finish。由于 start 方法是同步执行的，所以它会阻塞当前线程直到操作完成。

//基本使用
- (void)testBaseNSOperation{
    //处理事务
    NSInvocationOperation *op =  [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(handleInvocation:) object:@"XN"]; // object是传递参数
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];
    
    //操作加入队列
    [queue addOperation:op];   
}
- (void)handleInvocation:(id)operation{
    NSLog(@"%@ - %@", operation, [NSThread currentThread]);
}

NSOperation是个抽象类，实际运用时中需要使用它的子类

1、使用子类NSInvocationOperation

//直接处理事务，不添加隐性队列
- (void)createNSOperation{
    //创建NSInvocationOperation对象并关联方法，之后start。
    NSInvocationOperation *invocationOperation = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(doSomething:) object:@"xn"];
    
    [invocationOperation start];
}

在这里插入图片描述

当我们直接使用[invocationOperation start];时任务在主线程执行

2、使用子类NSBlockOperation

- (void)useBlockOperation {

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

    // 2.调用 start 方法开始执行操作
    [op start];
}

在这里插入图片描述
在没有使用NSOperationQueue，同时没有使用addExecutionBlock方法时不会开启新线程执行操作

同时通过addExecutionBlock就可以开启新线程执行操作

如果添加的操作多的话， blockOperationWithBlock: 中的操作也可能会在其他线程（非当前主线程）中执行，这是由系统决定的

- (void)testNSBlockOperationExecution{
  // 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];
}

输出：
在这里插入图片描述
使用子类 NSBlockOperation，并调用方法 AddExecutionBlock: 的情况下，blockOperationWithBlock:方法中的操作和 addExecutionBlock: 中的操作是在不同的线程中异步执行的。

3、定义继承自NSOperation的子类，通过实现内部相应的方法来封装任务。

//*********自定义继承自NSOperation的子类*********
@interface CJLOperation : NSOperation
@end

@implementation CJLOperation
- (void)main{
    for (int i = 0; i < 3; i++) {
        NSLog(@"NSOperation的子类：%@",[NSThread currentThread]);
    }
}
@end

//*********使用*********
- (void)cjl_testCJLOperation{
    //运用继承自NSOperation的子类 首先我们定义一个继承自NSOperation的类，然后重写它的main方法。
    CJLOperation *operation = [[CJLOperation alloc] init];
    [operation start];
}

输出：
在这里插入图片描述
可以看出：在没有使用 NSOperationQueue、在主线程单独使用自定义继承自 NSOperation 的子类的情况下，是在主线程执行操作，并没有开启新线程。

四、NSOperationQueue

NSOperationQueue添加事务
NSOperationQueue有两种队列：主队列、其他队列。其他队列包含了 串行和并发。

主队列
凡是添加到主队列中的操作，都会放到主线程中执行。

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

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

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

将操作加入到队列中

上边我们说到 NSOperation 需要配合 NSOperationQueue 来实现多线程。

那么我们需要将创建好的操作加入到队列中去。总共有两种方法：
1、- (void)addOperation:(NSOperation *)op;
需要先创建操作，再将创建好的操作加入到创建好的队列中去。

/**
 * 使用 addOperation: 将操作加入到操作队列中
 */
- (void)addOperationToQueue {

    // 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]
}

使用 NSOperation 子类创建操作，并使用 addOperation: 将操作加入到操作队列后能够开启新线程，进行并发执行。

NSOperationQueue 管理一个或多个 NSOperation 对象的执行。当你将 NSOperation 实例加入到 NSOperationQueue 时，你不需要手动创建和管理线程。操作队列自动处理这些细节。

2、- (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 控制的不是并发线程的数量，而是一个队列中同时能并发执行的最大操作数。而且一个操作也并非只能在一个线程中运行，一个操作可能很长，可以将其分散在多个线程中执行，比如我们在子线程更新数据后在主线程更新UI。

最大并发操作数：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]); // 打印当前线程
        }
    }];
}

maxConcurrentOperationCount = 1
在这里插入图片描述

可以看到任务按顺序串行执行

maxConcurrentOperationCount = 2

在这里插入图片描述
在并发操作数为2时可以执行两个操作，操作时并发施行的，而开启线程数量是由系统决定的，不需要我们来管理。

因为NSOperation由系统控制开启线程数量以及串行并行，而GCD需要我们手动控制

六、 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:op2];
    [queue addOperation:op1];
}

可以看到即使两个操作在不同线程执行也就是并发执行，也是op1先执行才能执行op2
在这里插入图片描述
去掉依赖：

七、NSOperation 优先级

NSOperation 提供了queuePriority（优先级）属性，queuePriority属性适用于同一操作队列中的操作

默认情况下，所有新创建的操作对象优先级都是NSOperationQueuePriorityNormal，但是我们可以通过setQueuePriority:方法来改变当前操作在同一队列中的执行优先级。

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

将操作添加到队列后操作会进入就绪状态，就绪状态的操作的执行顺序由操作之间的优先级决定

就绪状态的操作：简单理解就是准备就绪的操作就是没有需要依赖的操作，例如op2依赖于op1，那么op2就没有准备就绪，因为他需要等op1执行完才准备就绪

优先级不能取代依赖关系。如果要控制操作间的启动顺序，则必须使用依赖关系。

八、NSOperation、NSOperationQueue 线程间的通信

同样的我们在开发中常常在子线程中更新数据在主线程中更新UI，这在NSOperation中时如何实现的呢

/**
 * 线程间通信
 */
- (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 线程同步和线程安全

又到了老生常谈的售票问题

NSOperation、NSOperationQueue 非线程安全

因为使用NSOperation将操作添加到队列时系统后自动执行并发操作
因此如果不对线程进行加锁会出现如下状况

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

    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
    __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;
        }
    }
}

输出：
在这里插入图片描述

NSOperation、NSOperationQueue 非线程安全

使用互斥锁进行加锁后就得到了正确的票数

- (void)saleTicketNotSafe {
    while (1) {
        @synchronized (self) {
            if (self.ticketSurplusCount > 0) {
                //如果还有票，继续售卖
                self.ticketSurplusCount--;
                NSLog(@"%@", [NSString stringWithFormat:@"剩余票数:%d 窗口:%@", self.ticketSurplusCount, [NSThread currentThread]]);
                [NSThread sleepForTimeInterval:0.2];
            } else {
                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)waitUntilAllOperationsAreFinished; 阻塞当前线程，直到队列中的操作全部执行完毕。

添加/获取操作

- (void)addOperationWithBlock:(void (^)(void))block; 向队列中添加一个 NSBlockOperation 类型操作对象。
- (void)addOperations:(NSArray *)ops waitUntilFinished:(BOOL)wait; 向队列中添加操作数组，wait 标志是否阻塞当前线程直到所有操作结束
- (NSArray *)operations; 当前在队列中的操作数组（某个操作执行结束后会自动从这个数组清除）。
- (NSUInteger)operationCount; 当前队列中的操作数。

获取队列

+ (id)currentQueue; 获取当前队列，如果当前线程不是在 NSOperationQueue 上运行则返回 nil。
+ (id)mainQueue; 获取主队列。