NSOperationNSOperationQueue

Posted 2020-07-05 Kingdev

NSOperation、NSOperationQueue

NSOperation 和 NSOperationQueue 配合使用也能实现多线程。

NSOperation 继承于 NSObject，是一种抽象类，并不具备封装操作的能力，必须使用它的子类。

使用 NSOperation 子类的三种方式：

1.NSBlockOperation；

2.NSInvocationOperation；

3.自定义 NSOperation，实现内部相应方法。

NSOperation 和 NSOperationQueue实现多线程的步骤:

1)先将需要执行的操作封装到一个 NSOperation(相当于GCD中的任务) 对象中

2)然后将 NSOperation 对象添加到 NSOperationQueue 中

3)系统会自动将 NSOperationQueue 中的 NSOperation取出来

4)将取出的 NSOperation 封装的操作放到一条新线程中执行。

 

NSInvocationOperation：

#pragma mark - NSInvocationOperation使用1(没什么卵用)
- (void)invocationOp1 {
    // 1.创建操作
    NSInvocationOperation *invocationOp =    [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(downLoadImage:) object:@"invocationOp"];
    
    // 2.启动。方法 - (void)start; 表示操作直接在当前线程执行
    [invocationOp start];
}

#pragma mark - NSInvocationOperation使用2
- (void)invocationOp2 {
    // 1.创建操作
    NSInvocationOperation *invocationOp =    [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(downLoadImage:) object:@"invocationOp"];
    
    // 2. 创建队列
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];
    
    // 3.操作添加到队列，就会异步调度执行这个方法
    [queue addOperation:invocationOp];
}

#pragma mark - NSInvocationOperation使用3
- (void)invocationOp3 {
    // 1. 创建队列( NSOperationQueue 本质上是对GCD中的并发队列的封装)。
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];
    
    // 2.创建操作并添加到队列
    for (int i = 0; i < 10; i ++) {
        // 操作就是 GCD 里异步执行的任务
        NSInvocationOperation *invocationOp =        [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(downLoadImage:) object:@"invocationOp"];
        // 3.操作添加到队列，就会异步调度执行这个方法
        [queue addOperation:invocationOp];
    }
}


- (void)downLoadImage:(id)obj {
    NSLog(@"NSThread=%@  obj=%@", [NSThread currentThread], obj);
}

总结，NSOperationQueue 就是对 GCD 中队列的封装(主要是并发队列 和 主队列的封装)。而 NsOperation 相当于 GCD 中的任务。

 

NSBlockOperation

#pragma mark - NSBlockOperation
- (void)blockOp1 {
    // 1.创建队列(相当于 GCD 的并发队列)
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];
    
    // 2.创建多个操作
    for (int i = 0; i < 10; i ++) {
        NSBlockOperation *blockOp = [NSBlockOperation blockOperationWithBlock:^{
            NSLog(@"thread=%@  i=%d", [NSThread currentThread], i);
        }];
        // 把操作放到队列
        [queue addOperation:blockOp];
    }
}

#pragma mark - NSBlockOperation更简单方法
- (void)blockOp2 {
    // 1.创建队列(相当于 GCD 的并发队列)
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];
    
    // 2.创建多个操作
    for (int i = 0; i < 10; i ++) {
        [queue addOperationWithBlock:^{
            NSLog(@"thread=%@  i=%d", [NSThread currentThread], i);
        }];
    }
}

#pragma mark - NSOperationQueue相当于 GCD中的并发队列。但是也可以获取主线程和当前队列
- (void)operationQueue {
    // 1.创建队列(相当于 GCD 的并发队列)
    NSOperationQueue *queue = [NSOperationQueue mainQueue];
    
    // 2.创建多个操作
    for (int i = 0; i < 10; i ++) {
        // 操作就是 GCD 里异步执行的任务，并不会马上就执行
        NSBlockOperation *blockOp = [NSBlockOperation blockOperationWithBlock:^{
            NSLog(@"thread=%@  i=%d", [NSThread currentThread], i);
        }];
        // 把操作放到队列
        [queue addOperation:blockOp];
    }
    NSLog(@"完成·········");
}
打印结果：
2016-04-05 22:45:20.723 NSOperation[746:37832] 完成·········
2016-04-05 22:45:20.724 NSOperation[746:37832] thread=<NSThread: 0x7fa781703410>{number = 1, name = main}  i=0
2016-04-05 22:45:20.724 NSOperation[746:37832] thread=<NSThread: 0x7fa781703410>{number = 1, name = main}  i=1
2016-04-05 22:45:20.725 NSOperation[746:37832] thread=<NSThread: 0x7fa781703410>{number = 1, name = main}  i=2
2016-04-05 22:45:20.725 NSOperation[746:37832] thread=<NSThread: 0x7fa781703410>{number = 1, name = main}  i=3
2016-04-05 22:45:20.725 NSOperation[746:37832] thread=<NSThread: 0x7fa781703410>{number = 1, name = main}  i=4
2016-04-05 22:45:20.725 NSOperation[746:37832] thread=<NSThread: 0x7fa781703410>{number = 1, name = main}  i=5

 

NSOperation:

- (void)invocation_block_Op {
    // 创建队列
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];
    
    for (int i = 0; i < 6; i ++) {
        // 不创建操作，使用 - (void)addOperationWithBlock:(void (^)(void))block; 直接添加操作到队列
        [queue addOperationWithBlock:^{
            NSLog(@"耗时操作thread=%@ i=%d", [NSThread currentThread], i);
        }];
    }
    
    // 操作
    NSInvocationOperation *inOp = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(downLoadImage:) object:@"组团使用"];
    [queue addOperation:inOp];
    
    // block操作
    NSBlockOperation *blockOp = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"blockOperationWithBlock - thread=%@", [NSThread currentThread]);
    }];
    // - (void)addExecutionBlock:(void (^)(void))block; 添加的操作，和上面是同级别的操作
    [blockOp addExecutionBlock:^{
        NSLog(@"addExecutionBlock - thread=%@", [NSThread currentThread]);
    }];
    [queue addOperation:blockOp];
}
打印结果：
2016-04-06 08:03:37.854 NSOperation[935:102551] thread=<NSThread: 0x7fdf0c801b40>{number = 19, name = (null)} i=0
2016-04-06 08:03:37.854 NSOperation[935:102549] thread=<NSThread: 0x7fdf0a4311d0>{number = 17, name = (null)} i=2
2016-04-06 08:03:37.854 NSOperation[935:102542] thread=<NSThread: 0x7fdf0a7f9950>{number = 21, name = (null)} i=1
2016-04-06 08:03:37.854 NSOperation[935:102544] thread=<NSThread: 0x7fdf0a60c940>{number = 16, name = (null)} i=3
2016-04-06 08:03:37.854 NSOperation[935:102551] thread=<NSThread: 0x7fdf0c801b40>{number = 19, name = (null)} i=4
2016-04-06 08:03:37.854 NSOperation[935:102549] thread=<NSThread: 0x7fdf0a4311d0>{number = 17, name = (null)} i=5
2016-04-06 08:03:37.855 NSOperation[935:102546] NSThread=<NSThread: 0x7fdf0c802ba0>{number = 20, name = (null)}  obj=组团使用
2016-04-06 08:03:37.855 NSOperation[935:102542] blockOperationWithBlock - thread=<NSThread: 0x7fdf0a7f9950>{number = 21, name = (null)}
2016-04-06 08:03:37.855 NSOperation[935:102551] addExecutionBlock - thread=<NSThread: 0x7fdf0c801b40>{number = 19, name = (null)}

 

线程间通信：

#pragma mark - NSOperation 线程间通信
- (void)communicationBetweenThreads {
    // 创建队列
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];
    
    // 添加操作，异步执行
    [queue addOperationWithBlock:^{
        // 耗时操作
        // code····
        NSLog(@"耗时操作 : %@", [NSThread currentThread]);
        
        // 主线程刷新UI
        [[NSOperationQueue mainQueue] addOperationWithBlock:^{
            // code····
            NSLog(@"刷新UI : %@", [NSThread currentThread]);
        }];
    }];
}

#pragma mark - GCD 实现线程通讯
- (void)GCD_threads {
    // 全局并发队列异步执行
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        // 耗时操作
        // code····
        NSLog(@"耗时操作 : %@", [NSThread currentThread]);
        
        // 主线程刷新UI
        dispatch_async(dispatch_get_main_queue(), ^{
            // code····
            NSLog(@"刷新UI : %@", [NSThread currentThread]);
        });
    });
}
打印结果：
2016-04-06 09:36:55.421 NSOperation[1150:152737] 耗时操作 : <NSThread: 0x7fd72866a9c0>{number = 4, name = (null)}
2016-04-06 09:36:55.421 NSOperation[1150:152700] 耗时操作 : <NSThread: 0x7fd7287aaf50>{number = 3, name = (null)}
2016-04-06 09:36:55.422 NSOperation[1150:152493] 刷新UI : <NSThread: 0x7fd728704dc0>{number = 1, name = main}
2016-04-06 09:36:55.422 NSOperation[1150:152493] 刷新UI : <NSThread: 0x7fd728704dc0>{number = 1, name = main}

 

最大并发数：

同时执行的操作的数量。

#pragma mark - 最大并发数
- (void)max_concurrent {
    // 设置最大并发数，是同时执行的操作的数量
    self.queue.maxConcurrentOperationCount = 2;
    for (int i = 0; i < 10; i ++) {
        [self.queue addOperationWithBlock:^{
            [NSThread sleepForTimeInterval:2];
            NSLog(@"%@", [NSThread currentThread]);
        }];
    }
}
打印结果:
2016-04-06 12:54:09.065 NSOperation[2673:349657] <NSThread: 0x7fd5d8c70970>{number = 3, name = (null)}
2016-04-06 12:54:09.065 NSOperation[2673:349573] <NSThread: 0x7fd5d8c8d700>{number = 2, name = (null)}
2016-04-06 12:54:11.071 NSOperation[2673:349568] <NSThread: 0x7fd5d8d361c0>{number = 4, name = (null)}
2016-04-06 12:54:11.071 NSOperation[2673:349657] <NSThread: 0x7fd5d8c70970>{number = 3, name = (null)}
2016-04-06 12:54:13.073 NSOperation[2673:349657] <NSThread: 0x7fd5d8c70970>{number = 3, name = (null)}
2016-04-06 12:54:13.073 NSOperation[2673:349568] <NSThread: 0x7fd5d8d361c0>{number = 4, name = (null)}
2016-04-06 12:54:15.078 NSOperation[2673:349573] <NSThread: 0x7fd5d8c8d700>{number = 2, name = (null)}
2016-04-06 12:54:15.078 NSOperation[2673:349568] <NSThread: 0x7fd5d8d361c0>{number = 4, name = (null)}
2016-04-06 12:54:17.081 NSOperation[2673:349657] <NSThread: 0x7fd5d8c70970>{number = 3, name = (null)}
2016-04-06 12:54:17.081 NSOperation[2673:349568] <NSThread: 0x7fd5d8d361c0>{number = 4, name = (null)}
分析：最大并发数是同时执行的操作的数量。以上代码，我们实现的是每两秒执行一次(查看打印的时间)，每次执行两个操作。之所以所有相同的线程是因为：任务执行完毕之后，线程会被回收到线程池，然后再拿出来使用的过程！

 

挂起/恢复：

#pragma mark - 取消队列里面所有操作(已经执行的操作不会取消)
// 取消操作，并不影响队列的挂起状态
- (IBAction)cancelAllOpeation:(id)sender {
    
    // 取消队列里面所有操作(队列里的操作都被移除)
    [self.queue cancelAllOperations];
    NSLog(@"取消队列里面所有操作");
    
    /** 
     场景：用户点击下载视频A、B、C、D；
          然后点击 挂起队列(暂停)；
          再然后，点击取消所有操作；
          最后，再次点击下载视频    -----> 导致无法下载，原因是 : 所有操作已取消。(点击挂起/恢复按钮可以实现下载)
          
          添加如下代码，解决这个BUG
     */
    // 取消队列挂起状态(只要取消了队列里的操作，我们就取消队列的挂起状态，以便于后续的开始)
    self.queue.suspended = NO;
}


#pragma mark - 挂起/继续(挂起是对队列的挂起，挂起之后，队列不再添加操作到队列去执行；但是挂起不会影响已经执行的操作)
- (IBAction)pause:(id)sender {
    
    // 判断当前队列中是否有操作(防止用户先点击了“暂停/继续按钮”,导致队列被挂起之后，用户无法执行后续的操作)；
    if (self.queue.operationCount == 0) {
        NSLog(@"没有操作！！");
        return;
    }
    
    self.queue.suspended = !self.queue.isSuspended;
    if (self.queue.isSuspended) {
        NSLog(@"暂停");
    } else {
        NSLog(@"继续");
    }
}
结论:
@property (getter=isSuspended) BOOL suspended;  // 挂起/恢复队列
@property (readonly) NSUInteger operationCount; // 队列里面的操作数
- (void)cancelAllOperations;　// 取消所有操作(移除掉了)
可以配合使用，来实现需求。

 

设置依赖：

/**
 *  @brief 添加数组操作
 *
 *  @param ops  数组操作
 *  @param wait 是否等待.YES : 等待前面的操作执行完毕再执行该方法后面的操作。 NO : 不等待前面的操作执行完毕就执行后面的操作。
 */
- (void)addOperations:(NSArray<NSOperation *> *)ops waitUntilFinished:(BOOL)wait;

#pragma mark - 设置依赖 Methods
- (void)dependency {
    NSBlockOperation *blockOp1 = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"下载A：%@", [NSThread currentThread]);
    }];
    NSBlockOperation *blockOp2 = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"下载B：%@", [NSThread currentThread]);
    }];
    NSBlockOperation *blockOp3 = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"刷新UI：%@", [NSThread currentThread]);
    }];
    
    // 指定任务之间的依赖关系,依赖关系可以跨队列(子线程下载，主线程刷新UI)(不要出现循环依赖)
    [blockOp2 addDependency:blockOp1];
    [blockOp3 addDependency:blockOp2];
    
    // 并发队列中添加操作
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];
    [queue addOperations:@[blockOp1, blockOp2] waitUntilFinished:YES];
    
    // 主队列刷新UI
    [[NSOperationQueue mainQueue] addOperation:blockOp3];
    
    NSLog(@"执行完毕····");
}

 

参考文档：

NSOperation官方文档

NSOperationQueue官方文档