iOS多线程技术NSOperation回顾

NSOperation是苹果推荐使用的并发技术，它提供了一些用GCD不是很好实现的功能。NSOperation是基于GCD的面向对象的使用OC语言的封装。相比GCD，NSOperation的使用更加简单。NSOperation是一个抽象类，也就是说它并不能直接使用，而是应该使用它的子类。使用它的子类的方法有三种，使用苹果为我们提供的两个子类 NSInvocationOperation，NSBlockOperation和自定义继承自NSOperation的子类。

NSOperation的使用常常是配合NSOperationQueue来进行的。只要是使用NSOperation的子类创建的实例就能添加到NSOperationQueue操作队列之中，一旦添加到队列，操作就会自动异步执行（注意是异步）。如果没有添加到队列，而是使用start方法，则会在当前线程执行。

我们知道，线程间的通信主要是主线程与分线程之间进行的。主线程到分线程，NSOperation子类也有相应带参数的方法；而分线程到主线程，比如更新UI，它也有很方便的获取主队列（被添加到主队列的操作默认会在主线程执行）的方法：[NSOperationQueue mainQueue]。

一、NSInvocationOperation

1.单个NSInvocationOperation

<1>直接创建一个NSInvocationOperation的对象，然后调用start方法会直接在主线程执行

//1.创建
  NSOperation *op = [[NSInvocationOperation alloc]initWithTarget:self 
selector:@selector(downloadImage:) object:@"Invocation"];
 //2.start方法，直接在当前线程执行
    [op start];

#pragma mark - 调用的耗时操作,后面调用的耗时操作都是这个
- (void)downloadImage:(id)obj{
  NSLog(@"%@-----%@",[NSThread currentThread],obj);
}

输出 [1151:50868] <NSThread: 0x7fae624047b0>{number = 1, name = main}-----Invocation

<2>添加到NSOperationQueue

 //1.创建
  NSOperation *op = [[NSInvocationOperation alloc]initWithTarget:self 
selector:@selector(downloadImage:) object:@"Invocation"];
 //2.放到队列里面去
    NSOperationQueue *q = [[NSOperationQueue alloc]init];
  //只要把操作放到队列，会自动异步执行调度方法
    [q addOperation:op];

输出：[1192:55469] <NSThread: 0x7fbe59e45c30>{number = 3, name = (null)}-----Invocation

在number为3，name为空的子线程执行

2.多个NSInvocationOperation

    //队列，GCD里面的并发队列使用最多，所以NSOperation技术直接把GCD里面的并发队列封装起来
  //NSOperationQueue本质就是GCD里面的并发队列
  //操作就是GCD里面异步执行的任务
  NSOperationQueue *q = [[NSOperationQueue alloc]init];
 
  //把多个操作放到队列里面
  for (int i = 0; i < 100; i++) {
    NSOperation *op = [[NSInvocationOperation alloc]initWithTarget:self 
         selector:@selector(downloadImage:) object:[NSString stringWithFormat:@"Invocation%d",i]];
    [q addOperation:op];
  }

输出：
**[1222:58476] <NSThread: 0x7fdc14b0cd20>{number = 7, name = (null)}-----Invocation5
**[1222:58478] <NSThread: 0x7fdc1357e5f0>{number = 9, name = (null)}-----Invocation7
**[1222:58307] <NSThread: 0x7fdc14a06ad0>{number = 3, name = (null)}-----Invocation1
**[1222:58477] <NSThread: 0x7fdc134916e0>{number = 8, name = (null)}-----Invocation6
**[1222:58481] <NSThread: 0x7fdc1357e120>{number = 12, name = (null)}-----Invocation10
**[1222:58475] <NSThread: 0x7fdc14801710>{number = 6, name = (null)}-----Invocation4
**[1222:58480] <NSThread: 0x7fdc13415630>{number = 11, name = (null)}-----Invocation9
**[1222:58306] <NSThread: 0x7fdc13512e20>{number = 4, name = (null)}-----Invocation3
··· ···

线程名与输出均没有规律，很明显就是并发队列。

二、NSBlockOperation

NSBlockOperation的用法与NSInvocationOperation相同，只是创建的方式不同，它不需要去调用方法，而是直接使用代码块,显得更方便。这也使得NSBlockOperation比NSInvocationOperation更加流行

    //跟GCD中的并发队列一样
  NSOperationQueue *q = [[NSOperationQueue alloc]init];
  //跟GCD中的主队列一样
//  NSOperationQueue *q = [NSOperationQueue mainQueue];
  //把多个操作放到队列里面
  for (int i = 0; i < 100; i++) {
    NSBlockOperation *op = [NSBlockOperation blockOperationWithBlock:^{
      NSLog(@"%@------%d",[NSThread currentThread],i);
     
   }];
    //把Block操作放到队列
    [q addOperation:op];
  }
  NSLog(@"完成");

并发队列输出结果：
**[1378:72440] <NSThread: 0x7f9cb2603460>{number = 6, name = (null)}------5**
**[1378:72442] <NSThread: 0x7f9cb48106a0>{number = 5, name = (null)}------7**
**[1378:72441] <NSThread: 0x7f9cb242b3e0>{number = 7, name = (null)}------6**
**[1378:72325] <NSThread: 0x7f9cb4851550>{number = 9, name = (null)}------2**
**[1378:72320] <NSThread: 0x7f9cb492be70>{number = 4, name = (null)}------3**
**[1378:72313] <NSThread: 0x7f9cb24077b0>{number = 2, name = (null)}------1**
**[1378:72276] 完成
**[1378:72444] <NSThread: 0x7f9cb481cc40>{number = 11, name = (null)}------9**
**[1378:72326] <NSThread: 0x7f9cb4923fe0>{number = 3, name = (null)}------0**
**[1378:72440] <NSThread: 0x7f9cb2603460>{number = 6, name = (null)}------12**
... ...

主队列输出结果：
**[1417:76086] 完成
**[1417:76086] <NSThread: 0x7fa452e04360>{number = 1, name = main}------0**
**[1417:76086] <NSThread: 0x7fa452e04360>{number = 1, name = main}------1**
**[1417:76086] <NSThread: 0x7fa452e04360>{number = 1, name = main}------2**
**[1417:76086] <NSThread: 0x7fa452e04360>{number = 1, name = main}------3**
**[1417:76086] <NSThread: 0x7fa452e04360>{number = 1, name = main}------4**
**[1417:76086] <NSThread: 0x7fa452e04360>{number = 1, name = main}------5**
**[1417:76086] <NSThread: 0x7fa452e04360>{number = 1, name = main}------6**
**[1417:76086] <NSThread: 0x7fa452e04360>{number = 1, name = main}------7**
... ...

事实上NSBlockOperation有更简单的使用方法

NSOperationQueue *q = [[NSOperationQueue alloc]init];
 
  for (int i = 0; i < 10; i++) {
   
    [q addOperationWithBlock:^{
      NSLog(@"%@------%d",[NSThread currentThread],i);
    }];
  }

三、线程间通信

主线程到子线程传对象，前面的例子里面已经有了，不再缀述。下面的例子就是回到主线程更新UI。

p.p1 {margin: 0.0px 0.0px 0.0px 0.0px; font: 14.0px Menlo; c

NSOperationQueue *q = [[NSOperationQueue alloc]init];

  [q addOperationWithBlock:^{
    NSLog(@"耗时操作--%@",[NSThread currentThread]);
    [[NSOperationQueue mainQueue] addOperationWithBlock:^{
      NSLog(@"更新UI-----%@",[NSThread currentThread]);
    }];
  }];

四、NSOperationQueue的一些高级操作

NSOperationQueue支持的高级操作有：队列的挂起，队列的取消，添加操作的依赖关系和设置最大并发数

<1>最大并发数

@property (nonatomic,strong)NSOperationQueue *opQueue;

//重写getter方法实现懒加载
- (NSOperationQueue*)opQueue{
  if (_opQueue == nil) {
    _opQueue = [[NSOperationQueue alloc]init]; 
  }
  return _opQueue;
}


#pragma mark - 高级操作:最大并发数

  //设置最大的并发数量（并非线程的数量）
  self.opQueue.maxConcurrentOperationCount = 2;
  //把多个操作放到队列里面
  for (int i = 0; i < 10; i++) {
    NSBlockOperation *op = [NSBlockOperation blockOperationWithBlock:^{
      [NSThread sleepForTimeInterval:3.0];
      NSLog(@"%@------%d",[NSThread currentThread],i);
     
    }];
    //把Block操作放到队列
    [self.opQueue addOperation:op];
  }

<2>线程的挂起

#pragma mark - 高级操作：线程的挂起
//暂停继续(对队列的暂停和继续)，挂起的是队列，不会影响已经在执行的操作
- (IBAction)pause:(UIButton *)sender {
  //判断操作的数量，当前队列里面是不是有操作？
  if (self.opQueue.operationCount == 0) {
    NSLog(@"当前队列没有操作");
    return;
  }
 
  self.opQueue.suspended = !self.opQueue.isSuspended;
  if (self.opQueue.suspended) {
    NSLog(@"暂停");
   
  }else{
    NSLog(@"继续");
  }
}

<3>取消队列里的所有操作

#pragma mark - 高级操作：取消队列里的所有操作
- (IBAction)cancelAll:(UIButton *)sender {
  //只能取消所有队列的里面的操作，正在执行的无法取消
  //取消操作并不会影响队列的挂起状态
  [self.opQueue cancelAllOperations];
  NSLog(@"取消队列里所有的操作");
  //取消队列的挂起状态
  //（只要是取消了队列的操作，我们就把队列处于不挂起状态,以便于后续的开始）
  self.opQueue.suspended = NO;
 
}

<4>依赖关系

    /*
  * 例子
  *
  * 1.下载一个小说压缩包
  *  2.解压缩，删除压缩包
  * 3.更新UI
  */
 
  NSBlockOperation *op1 = [NSBlockOperation blockOperationWithBlock:^{
    NSLog(@"1.下载一个小说压缩包,%@",[NSThread currentThread]);
   
  }];
 
  NSBlockOperation *op2 = [NSBlockOperation blockOperationWithBlock:^{
    NSLog(@"2.解压缩，删除压缩包,%@",[NSThread currentThread]);
   
  }];
 
  NSBlockOperation *op3 = [NSBlockOperation blockOperationWithBlock:^{
    NSLog(@"3.更新UI,%@",[NSThread currentThread]);
   
  }];
 
  //指定任务之间的依赖关系 --依赖关系可以跨队列(可以再子线程下载，在主线程更新UI)
 
  [op2 addDependency:op1];
  [op3 addDependency:op2];
//  [op1 addDependency:op3];  一定不能出现循环依赖
 
  //waitUntilFinished  类似GCD中的调度组的通知
  //NO不等待，直接执行输出come here
  //YES等待任务执行完再执行输出come here
  [self.opQueue addOperations:@[op1,op2] waitUntilFinished:YES];
 
 
  //在主线程更新UI
  [[NSOperationQueue mainQueue] addOperation:op3];
  [op3 addDependency:op2];
  NSLog(@"come here");

还有一个NSOperationQueuePriority，队列优先级，感兴趣的同学可以查看官网文档：NSOperationQueuePriority