iOS基础 - NSOperation | NSOperationQueue

▶ NSOperation

NSOperation 在 MVC 中属于 M 层，是用来封装单个任务相关代码和数据的抽象类。它不能够直接使用，必须使用其子类。使用⼦类有三种方式

A - NSInvocationOperation：封装了执行操作的 target 和要执行的 action

B - NSBlockOperation ：封装了要执行的代码块

C - 自定义其子类

注：使用 Operation 的目的就是为了让开发人员不再关心线程！NSOperation 本身并无主、子线程之分，可在任意线程中使用，通常和 NSOperationQueue 搭配使用。队列用来管理一组操作对象的执行，它会根据需要自动为操作开辟合适数量的线程以完成任务的并发执行

NSInvocationOperation 调⽤ start ⽅法来执⾏任务，默认同步执行

- (void)viewDidLoad {
    [super viewDidLoad];

    // 封装要执行的任务
    NSInvocationOperation *operationA = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(testOperationA:) object:@"operationA"];
    // 执行操作
    [operationA start];
}

- (void)testOperationA:(NSString *)name{
    // 操作对象默认在当前线程中执行（这里是主线程），只有添加到队列中时才会开启新的线程
    NSLog(@"%@",[NSThread currentThread]); // <_NSMainThread: 0x600003ff8480>{number = 1, name = main}
}

NSBlockOperation 是否会开启线程，关键是看所封装操作数

- (void)viewDidLoad {
    [super viewDidLoad];

    NSBlockOperation *operationB = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"%@",[NSThread currentThread]);//  当前线程：<_NSMainThread: 0x60000331c000>{number = 1, name = main}
    }];
    [operationB start];
}

只要封装的操作数 > 1，就会异步执行

- (void)viewDidLoad {
    [super viewDidLoad];

    NSBlockOperation *operationC = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"%@",[NSThread currentThread]); // 当前线程：<_NSMainThread: 0x6000027ec540>{number = 1, name = main}
    }];

    
    // 以下会开辟新线程，且 block 之间是并发执行的
    // 会开辟新的线程
    [operationC addExecutionBlock:^{
        NSLog(@"添加1 = %@",[NSThread currentThread]); // 添加1 = <NSThread: 0x6000027a1b80>{number = 4, name = (null)}
    }];

    // 会开辟新的线程
    [operationC addExecutionBlock:^{
        NSLog(@"添加2 = %@",[NSThread currentThread]); // 添加2 = <NSThread: 0x6000027b0cc0>{number = 6, name = (null)}
    }];
    [operationC start];
        
}

▶ NSOperationQueue

我们知道 NSInvocationOperation 默认在当前线程中执行；如果将操作添加到队列中系统就会自动异步执行：系统自动把队列中的操作对象取出，将其封装到一条新的线程中执行。下面就把操作对象添加到 NSOperationQueue 中

- (void)viewDidLoad {
    [super viewDidLoad];

    // 搞 3 个操作对象
    NSInvocationOperation *operation1 = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(testOperation1) object:nil];
    NSInvocationOperation *operation2 = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(testOperation2) object:nil];
    NSBlockOperation *operation3 = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"operation3-1--%@",[NSThread currentThread]);
    }];
    [operation3 addExecutionBlock:^{
        NSLog(@"operation3-2--%@",[NSThread currentThread]);
    }];
    
    // 将操作对象添加进队列
    NSOperationQueue *operationsQueue = [NSOperationQueue new];
    // [operationsQueue setSuspended:YES]; // 暂停队列
    [operationsQueue addOperation:operation1];
    [operationsQueue addOperation:operation2];
    [operationsQueue addOperation:operation3];
    
    operation2.queuePriority = NSOperationQueuePriorityHigh; // 优先级
    // [operation3 cancel]; // 取消单个操作
    // [operationsQueue cancelAllOperations]; // 取消全部操作
}

日志信息

上面的代码一共有四个任务：operation1 和 operation2 各有一个任务；operation3 有两个任务；也就意味着开启了 4条线程 

注：如果操作、队列两者配合使用的话，那么就应当禁止操作的开启，否则程序 crash

- (void)viewDidLoad {
    [super viewDidLoad];

    NSInvocationOperation *operationD = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(testOperationD) object:nil];
    [operationD start];// 不应开启

    // 把操作对象添加进队列
    NSOperationQueue *queueD = [[NSOperationQueue alloc] init];
    [queueD setMaxConcurrentOperationCount:1];
    [queueD addOperation:operationD];// crash
}

- (void)testOperationD{
    NSLog(@"operationD--%@",[NSThread currentThread]);
}

▶ 常用API

并发数：同时执⾏的任务数。最大并发数：同一时间最多只能执行的任务的个数。如果没有设置最大并发数，那么并发的个数是由系统内存和 CPU 决定的，最大并发数建议不要乱写（5 以内），一般以 2~3 为宜

- (NSInteger)maxConcurrentOperationCount;
- (void)setMaxConcurrentOperationCount:(NSInteger)cnt;

取消操作：取消队列中的所有操作；也可以调用 NSOperation 的 - (void)cancel ⽅法取消单个操作 

// NSOperation
- (void)cancel;
// NSOperationQueue
- (void)cancelAllOperations;

暂停和恢复队列：其适用场合，比如在 tableview 界面里开启线程下载网络时会对 UI 会有所影响使用户体验变差，那么这种情况就可以设置当用户操作 UI（如滚动屏幕）时暂停队列而不是取消队列，在停止滚动时恢复队列

- (void)setSuspended:(BOOL)b;
- (BOOL)isSuspended;

操作优先级：NSOperation 在 queue 中的优先级。注：优先级高的任务只能保证被调用的几率会更大，而不是一定就优先执行

- (NSOperationQueuePriority)queuePriority;
- (void)setQueuePriority:(NSOperationQueuePriority)p;

// 优先级
NSOperationQueuePriorityVeryLow  = -8L,
NSOperationQueuePriorityLow      = -4L,
NSOperationQueuePriorityNormal   = 0,
NSOperationQueuePriorityHigh     = 4,
NSOperationQueuePriorityVeryHigh = 8

操作监听：可以监听一个操作的结束

- (void (^)(void))completionBlock;
- (void)setCompletionBlock:(void (^)(void))block; 

等待 block 代码块执行完毕后，执行 结束！输出语句

NSBlockOperation *operationE = [NSBlockOperation blockOperationWithBlock:^{
    for (int i = 0; i<5; i++) {
        [NSThread sleepForTimeInterval:1.5];
        NSLog(@"%d",i);
    }
}];

// block 执行完毕后调用
operationE.completionBlock = ^{
    NSLog(@"结束！");
};

NSOperationQueue *queueE = [[NSOperationQueue alloc]init];
[queueE addOperation:operationE];

▶ 操作依赖

NSOperation 之间可以设置依赖来保证执行顺序，⽐如一定要让 操作A 执行完后才能执行 操作B。当然，我们完全可以在不同 queue 的 NSOperation 之间创建依赖关系，这时需要注意循环依赖问题（A 依赖于 B 且 B 又依赖于 A）注：依赖一定要在操作添加进队列之前进行设置。 

使用依赖关系使线程有序执行

- (void)viewDidLoad {
    [super viewDidLoad];
    
    // 操作依赖
    NSInvocationOperation *operationK = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(testOperationK) object:nil];
    NSInvocationOperation *operationL = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(testOperationL) object:nil];
    NSBlockOperation *operationO = [NSBlockOperation blockOperationWithBlock:^{
        for (int i=0; i<3; i++) {
            NSLog(@"operationO---1---%@",[NSThread currentThread]);
        }
    }];
    [operationO addExecutionBlock:^{
        for (int i=0; i<3; i++) {
            NSLog(@"operationO---2---%@",[NSThread currentThread]);
        }
    }];

    // 监听结束
    operationO.completionBlock = ^{
        NSLog(@"operationO---结束");
    };
    operationL.completionBlock = ^{
        NSLog(@"operationL---结束");
    };
    operationK.completionBlock = ^{
        NSLog(@"operationK---结束");
    };

    // 依次执行 operationO   operationL   operationK
    [operationK addDependency:operationL];
    [operationL addDependency:operationO];

    NSOperationQueue *operationsQueueQ = [[NSOperationQueue alloc] init];
    [operationsQueueQ addOperation:operationK];
    [operationsQueueQ addOperation:operationL];
    [operationsQueueQ addOperation:operationO];

}

-(void)testOperationK{
    NSLog(@"--testOperationK--%@",[NSThread currentThread]);
}

-(void)testOperationL{
    NSLog(@"--testOperationL--%@",[NSThread currentThread]);
}

日志信息