NSOperation之依赖关系和GCD之间的对比

逃离我推掉我的手 2022-08-09 12:41 175阅读 0赞

NSOperation之间可以设置依赖来保证执行顺序，这是GCD所不具备的功能：

比如一定要让操作A执行完后，才能执行操作B，可以这么写：

\[operationB addDependency:operationA\];  // 操作B依赖于操作A

可以在不同Queue的NSOperation之间创建依赖关系，切记不要造成相互依赖。如下图所示：

![Center][]

与GCD之间的区别如下：

GCD----> ios4.0

- 具体使用：将任务（block）添加到队列（串行/并发（全局）），指定执行任务的方法(同步(阻塞)/异步)

- 线程通信：获取主线程dispatch\_get\_main\_queue()。在主线程更新UI

-  还有NSOperation无法做到的事：一次性执行，延迟执行，调度组（NSOperation相对复杂）

NSOperation ---->ios2.0（后来改造了NSOperation的底层）

- 具体使用：将操作（异步执行的）添加到队列(并发/全局)。其实就是封装了GCD里的异步执行全局或并发队列。

- 线程通信： \[\[NSOperationQueue mainQueue\] addOperation:op3\]；拿到主队列，往主队列添加操作(更新UI)

- 提供了一些GCD无法实现的功能：“最大并发数”

- 暂停/继续 \-------挂起

- 取消所有任务

- 依赖关系

具体代码如下所示：

<span style="font-size:18px;">//
    //  ViewController.m
    //  NSOperation之线程间通信
    //
    //  Created by apple on 15/10/22.
    //  Copyright (c) 2015年 LiuXun. All rights reserved.
    //
    
    #import "ViewController.h"
    
    @interface ViewController ()
    /**
     一般开发中，会定义一个全局的队列。整个程序都可以把操作往里面放。
     负责调度所有的操作
     */
    @property(nonatomic, strong) NSOperationQueue *opQueue;
    @end
    
    @implementation ViewController
    
    /**
     小结：
     只要是NSOperation的子类，就能添加到操作队列
     - 一旦操作添加到队列， 就会自动异步执行
     - 如果没有添加到队列， 而是使用start方法，就会在当前线程执行操作
     - 如果是线程间通信， 可以使用[NSOperaionQueue mainQueue] 拿到主队列，往主队列添加操作（更新UI）
     */
    
    /**
     GCD----> ios4.0
     - 具体使用：将任务（block）添加到队列 （串行/并发（全局）） ，指定执行任务的方法(同步(阻塞)/异步)
     - 线程通信：获取主线程dispatch_get_main_queue()。在主线程更新UI
     -  还有NSOperation无法做到的事：一次性执行，延迟执行，调度组（NSOperation相对复杂）
     
     NSOperation ---->ios2.0 （后来改造了NSOperation的底层）
     - 具体使用：将操作（异步执行的）添加到队列(并发/全局)。其实就是封装了GCD里的异步执行全局或并发队列。
     - 线程通信： [[NSOperationQueue mainQueue] addOperation:op3]；拿到主队列，往主队列添加操作(更新UI)
     - 提供了一些GCD无法实现的功能：“最大并发数”
     - 暂停/继续 ------- 挂起
     - 取消所有任务
     - 依赖关系
     */
    
    /**
     懒加载的方式，初始化NSOperationQueue对象
     */
    -(NSOperationQueue *)opQueue
    {
        if(_opQueue == nil)
        {
            _opQueue = [[NSOperationQueue alloc] init];
        }
        return _opQueue;
    }
    -(void)touchesBegan:(NSSet *)touches withEvent:(UIEvent *)event
    {
        [self dependcy];
    }
    #pragma mark - 线程间通信（非常重要）
    -(void)opDemo1
    {
        NSOperationQueue *q = [[NSOperationQueue alloc] init];
        [q addOperationWithBlock:^{
            NSLog(@"耗时操作......%@", [NSThread currentThread]);
            
            // 在主线程更新UI
            [[NSOperationQueue mainQueue] addOperationWithBlock:^{
                NSLog(@"更新UI......%@", [NSThread currentThread]);
            }];
        }];
    }
    
    #pragma mark- 最大并发数
    /**
     注意：最大并发数不是说线程的数量，而是说同时进行操作的数量
     */
    -(void)opDemo2
    {
        self.opQueue.maxConcurrentOperationCount = 2;
        for(int i=0; i<10 ; i++){
            NSOperation *op = [NSBlockOperation blockOperationWithBlock:^{
                [NSThread sleepForTimeInterval:1.0];
                NSLog(@"%@------%d", [NSThread currentThread], i);
            }];
            [self.opQueue addOperation:op];
        }
    }
    
    #pragma mark - 高级操作  挂起
    // 就是暂停和继续:  对队列的操作
    /**
     应用场景：比如当我们在有WiFi的地发用手机下载电影，但是有事情走开了，断网了电影只下载了一半，这时就需要挂起，等到了有网的地方又可以接着原来的进度下载。
     切记：挂起的是队列，不会影响已经在执行的操作
     */
    -(IBAction)pause
    {
        
        // 判断操作的数量，当前队列里面是否有操作
        if(self.opQueue.operationCount == 0){
            NSLog(@"没有操作");
            return; // 没有操作的时候直接return，不会修改队列的状态
        }
        
        // 暂停继续 :
        self.opQueue.suspended = !self.opQueue.suspended;
        if(self.opQueue.suspended){
            NSLog(@"暂停");
        }else
        {
            NSLog(@"继续");
        }
    }
    
    #pragma mark- 高级操作 队列取消
    /**
     取消操作并不会影响队列的挂起状态
     */
    -(IBAction)cancel
    {
        // 取消队列内的所有操作
        // 只是取消队列里的任务，而正在执行的任务是无法取消的
        // 另外取消了任务就是删除了队列内的所有操作
        [self.opQueue cancelAllOperations];
        NSLog(@"取消所有操作");
        
        // 取消队列的挂起状态(只要是取消了队列的操作，我们就把队列处于一个启动状态，以便于后续的开始)
        self.opQueue.suspended = NO;
    }
    
    #pragma mark -依赖关系
    -(void)dependcy
    {
        /**
         举例场景：
         1. 下载一个小说的压缩包
         2. 解压缩，删除压缩包
         3. 更新UI
         */
        NSBlockOperation *op1 = [NSBlockOperation blockOperationWithBlock:^{
            NSLog(@"下载一个小说的压缩包，%@",[NSThread currentThread]);
        }];
        NSBlockOperation *op2 = [NSBlockOperation blockOperationWithBlock:^{
            NSLog(@"解压缩，删除压缩包，%@",[NSThread currentThread]);
        }];
        NSBlockOperation *op3 = [NSBlockOperation blockOperationWithBlock:^{
            NSLog(@"更新UI，%@",[NSThread currentThread]);
        }];
        // 如果直接把任务添加到队里，会异步执行，使顺序错乱
        
        // 因此需要指定任务之间的依赖关系--------依赖关系可以跨队列(可以在子线程下载完，到主线程更新UI)
        [op2 addDependency:op1];  // op2 依赖于op1  就是执行op2之前必须先执行op1
        [op3 addDependency:op2];  // op3 依赖于op2  就是执行op3之前必须先执行op2
        
        /**
         千万注意：不要造成相互依赖即依赖循环，会造成死锁
         */
        //    [op1 addDependency:op3];
        
        
        // waitUntilFinished 类似于GCD中调度组的通知
        // NO表示不等待当前的队列执行完毕，就执行下面的代码，打印 NSLog(@"任务完成");
        // YES 表示必须等队列内的任务全部执行完毕才执行下面的代码
        [ self.opQueue addOperations:@[op1, op2] waitUntilFinished:YES];
        
        // 在主线程更新UI
        [[NSOperationQueue mainQueue] addOperation:op3];
        
        NSLog(@"任务完成");
    }
    @end
    </span>

运行结果如下：

![Center 1][]

![Center 2][]

![Center 3][]

[Center]: /images/20220731/d839fa9f83e94863a1e245cf15ec03f9.png
[Center 1]: /images/20220731/fa41db6b78144ff5a2f12f2a49407eb0.png
[Center 2]: /images/20220731/f567d6c417064851affe2410e3e344d5.png
[Center 3]: /images/20220731/47f9a5430cf5477ea0a890646377abb2.png