iOS底层原理总结 - NSOperation详尽总结

2019-05-20 本文已影响29人二斤寂寞

目录：
1.NSOperation简介
2.NSOperation的创建
2.1NSInvocationOperation
2.2NSBlockOperation（最常用）
2.3自定义子类继承NSOperation，实现内部相应的方法
3.NSOperation的重要属性和方法
3.1依赖
3.2操作监听
3.3NSOperation的一些其他属性和方法
4.1NSOperationQueue的重要属性和方法
4.1.1最大并发数
4.1.2线程的挂起
4.1.3取消队列里的所有操作
4.1.4依赖关系
4.2NSOperationQueue的一些其他属性和方法
5.NSOperation和NSOperationQueue结合使用创建多线程
6.NSOperation线程之间的通信

1.NSOperation简介

NSOperation-Demo
NSOperation是苹果推荐使用的并发技术，它提供了一些用GCD不是很好实现的功能。
NSOperation是基于GCD的面向对象的使用OC语言的封装。相比GCD，NSOperation的使用更加简单。

2.NSOperation的创建

NSOperation是一个抽象类，也就是说它并不能直接使用，而是应该使用它的子类。使用它的子类的方法有三种，使用苹果为我们提供的两个子类 NSInvocationOperation，NSBlockOperation和自定义继承自NSOperation的子类。
NSOperation的使用常常是配合NSOperationQueue来进行的。只要是使用NSOperation的子类创建的实例就能添加到NSOperationQueue操作队列之中，一旦添加到队列，操作就会自动异步执行（注意是异步）。如果没有添加到队列，而是使用start方法，则会在当前线程执行。

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

2.1NSInvocationOperation

单个NSInvocationOperation

- (void)invocationOperation {
    /*
     第一个参数:目标对象
     第二个参数:选择器,要调用的方法
     第三个参数:方法要传递的参数
     */
    NSOperation *op = [[NSInvocationOperation alloc]initWithTarget:self
                                                          selector:@selector(downloadImage:) object:@"Invocation"];
    //2.start方法，直接在当前线程执行
    [op start];
}

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

运行结果：

NSInvocationOperation.png

注意：默认情况下，调用了start方法后并不会开一条新的线程去执行，而是在当前线程同步执行操作，只有将NSOperation放到一个 NSOperationQueue 中，才会异步执行操作

添加到NSOperationQueue：

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

运行结果：

invocationOperationAddQueue.png

可以看出：
在number为3，name为空的子线程执行。

多个NSInvocationOperation

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

运行结果：

invocationOperationMore.png

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

2.2NSBlockOperation（最常用）

NSBlockOperation 不论封装操作还是追加操作都是异步并发执行
方式一：

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

方式二：

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

方式三：

- (void)blockOperation3 {
    //1.封装操作
    NSBlockOperation *op = [NSBlockOperation blockOperationWithBlock:^{
        // 要执行的操作，在主线程中执行
        NSLog(@"1------%@",[NSThread currentThread]);
    }];
    //2.追加操作，追加的操作在子线程中执行，可以追加多条操作
    [op addExecutionBlock:^{
        NSLog(@"---download2--%@",[NSThread currentThread]);
    }];
    
    [op addExecutionBlock:^{
        NSLog(@"---download3--%@",[NSThread currentThread]);
    }];
    
    [op addExecutionBlock:^{
        NSLog(@"---download4--%@",[NSThread currentThread]);
    }];
    [op start];
}

运行结果：

NSBlockOperation.png

可以看出：
异步执行代码。

2.3自定义子类继承NSOperation，实现内部相应的方法

需要实现- (void)main方法，需要做的事情放在mian方法中
自定义类封装性高，复用性高。

// 重写自定义类的main方法实现封装操作
-(void)main
{
    // 要执行的操作
}

// 实例化一个自定义对象，并执行操作
CLOperation *op = [[CLOperation alloc]init];
[op start];

3.NSOperation的重要属性和方法

NSOperation中的两种队列
主队列：通过mainQueue获得，凡是放到主队列中的任务都将在主线程执行
非主队列：直接alloc init出来的队列。非主队列同时具备了并发和串行的功能，通过设置最大并发数属性来控制任务是并发执行还是串行执行

3.1依赖

// 操作op1依赖op5，即op1必须等op5执行完毕之后才会执行
// 添加操作依赖,注意不能循环依赖，如果循环依赖会造成两个任务都不会执行
// 也可以夸队列依赖，依赖别的队列的操作
    [op1 addDependency:op5];

3.2操作监听

// 监听操作的完成
// 当op1线程完成之后，立刻就会执行block块中的代码
// block中的代码与op1不一定在一个线程中执行，但是一定在子线程中执行
op1.completionBlock = ^{
        NSLog(@"op1已经完成了---%@",[NSThread currentThread]);
    };

3.3NSOperation的一些其他属性和方法

// 开启线程
- (void)start;
- (void)main;
// 判断线程是否被取消
@property (readonly, getter=isCancelled) BOOL cancelled;
// 取消当前线程
- (void)cancel;
//NSOperation任务是否在运行
@property (readonly, getter=isExecuting) BOOL executing;
//NSOperation任务是否已结束
@property (readonly, getter=isFinished) BOOL finished;
// 添加依赖
- (void)addDependency:(NSOperation *)op;
// 移除依赖
- (void)removeDependency:(NSOperation *)op;
// 优先级
typedef NS_ENUM(NSInteger, NSOperationQueuePriority) {
    NSOperationQueuePriorityVeryLow = -8L,
    NSOperationQueuePriorityLow = -4L,
    NSOperationQueuePriorityNormal = 0,
    NSOperationQueuePriorityHigh = 4,
    NSOperationQueuePriorityVeryHigh = 8
};
// 操作监听
@property (nullable, copy) void (^completionBlock)(void) NS_AVAILABLE(10_6, 4_0);
// 阻塞当前线程，直到该NSOperation结束。可用于线程执行顺序的同步
- (void)waitUntilFinished NS_AVAILABLE(10_6, 4_0);
// 获取线程的优先级
@property double threadPriority NS_DEPRECATED(10_6, 10_10, 4_0, 8_0);
// 线程名称
@property (nullable, copy) NSString *name NS_AVAILABLE(10_10, 8_0);
@end

4NSOperationQueue的一些高级操作

NSOperationQueue的作用
NSOperation可以调用start方法来执行任务，但默认是同步执行的
如果将NSOperation添加到NSOperationQueue（操作队列）中，系统会自动异步执行NSOperation中的操作

添加操作到NSOperationQueue中
- (void)addOperation:(NSOperation *)op;
- (void)addOperationWithBlock:(void (^)(void))block;

注意：将操作添加到NSOperationQueue中，就会自动启动，不需要再自己启动了addOperation 内部调用 start方法
start方法内部调用 main方法

4.1NSOperationQueue的重要属性和方法

4.1.1最大并发数

   - (void)demo {
    /*
     默认是并发队列,如果最大并发数>1,并发
     如果最大并发数==1,串行队列
     系统的默认是最大并发数-1 ,表示不限制
     设置成0则不会执行任何操作
     */
    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];
    }
}

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

4.1.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(@"继续");
  }
}

4.1.3取消队列里的所有操作

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

}

注意：暂停和取消只能暂停或取消处于等待状态的任务，不能暂停或取消正在执行中的任务，必须等正在执行的任务执行完毕之后才会暂停，如果想要暂停或者取消正在执行的任务，可以在每个任务之间即每当执行完一段耗时操作之后，判断是否任务是否被取消或者暂停。如果想要精确的控制，则需要将判断代码放在任务之中，但是不建议这么做，频繁的判断会消耗太多时间

4.1.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");

4.2NSOperationQueue的一些其他属性和方法

// 获取队列中的操作
@property (readonly, copy) NSArray<__kindof NSOperation *> *operations;
// 队列中的操作数
@property (readonly) NSUInteger operationCount NS_AVAILABLE(10_6, 4_0);
// 最大并发数，同一时间最多只能执行三个操作
@property NSInteger maxConcurrentOperationCount;
// 暂停 YES:暂停 NO:继续
@property (getter=isSuspended) BOOL suspended;
// 取消所有操作
- (void)cancelAllOperations;
// 阻塞当前线程直到此队列中的所有任务执行完毕
- (void)waitUntilAllOperationsAreFinished;

5.NSOperation和NSOperationQueue结合使用创建多线程

    注：这里使用NSBlockOperation示例，其他两种方法一样
    // 1. 创建非主队列 同时具备并发和串行的功能，默认是并发队列
    NSOperationQueue *queue =[[NSOperationQueue alloc]init];
    //NSBlockOperation 不论封装操作还是追加操作都是异步并发执行
    // 2. 封装操作
    NSBlockOperation *op1 = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"download1 -- %@",[NSThread currentThread]);
    }];
    // 3. 将封装操作加入主队列
    // 也可以不获取封装操作对象 直接添加操作到队列中
    //[queue addOperationWithBlock:^{
    // 操作
    //}];
    [queue addOperation:op1];

6.NSOperation线程之间的通信

NSOperation线程之间的通信方法

// 回到主线程刷新UI
[[NSOperationQueue mainQueue]addOperationWithBlock:^{
      self.imageView.image = image;
}];

我们同样使用下载多张图片合成综合案例

#import "ViewController.h"
@interface ViewController ()
@property (weak, nonatomic) IBOutlet UIImageView *imageView;
@property(nonatomic,strong)UIImage *image1;
@property(nonatomic,strong)UIImage *image2;
@end
@implementation ViewController

-(void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
{
    // 创建非住队列
    NSOperationQueue *queue = [[NSOperationQueue alloc]init];
    // 下载第一张图片
    NSBlockOperation *download1 = [NSBlockOperation blockOperationWithBlock:^{
        NSURL *url = [NSURL URLWithString:@"http://img2.3lian.com/2014/c7/12/d/77.jpg"];
        NSData *data = [NSData dataWithContentsOfURL:url];
        self.image1 = [UIImage imageWithData:data];
    }];
    // 下载第二张图片
    NSBlockOperation *download2 = [NSBlockOperation blockOperationWithBlock:^{
        NSURL *url = [NSURL URLWithString:@"http://img2.3lian.com/2014/c7/12/d/77.jpg"];
        NSData *data = [NSData dataWithContentsOfURL:url];
        self.image2 = [UIImage imageWithData:data];
    }];
    // 合成操作
    NSBlockOperation *combie = [NSBlockOperation blockOperationWithBlock:^{
        // 开启图形上下文
        UIGraphicsBeginImageContext(CGSizeMake(375, 667));
        // 绘制图片1
        [self.image1 drawInRect:CGRectMake(0, 0, 375, 333)];
        // 绘制图片2
        [self.image2 drawInRect:CGRectMake(0, 334, 375, 333)];
        // 获取合成图片
        UIImage *image = UIGraphicsGetImageFromCurrentImageContext();
        // 关闭图形上下文
        UIGraphicsEndImageContext();
        // 回到主线程刷新UI
        [[NSOperationQueue mainQueue]addOperationWithBlock:^{
            self.imageView.image = image;
        }];
    }];
    // 添加依赖，合成图片需要等图片1，图片2都下载完毕之后合成
    [combie addDependency:download1];
    [combie addDependency:download2];
    // 添加操作到队列
    [queue addOperation:download1];
    [queue addOperation:download2];
    [queue addOperation:combie];
}
@end

注意：子线程执行完操作之后就会立即释放，即使我们使用强引用引用子线程使子线程不被释放，也不能给子线程再次添加操作，或者再次开启。

参考文章：
https://juejin.im/post/5a9e57af6fb9a028df222555
https://imlifengfeng.github.io/article/533/

iOS底层原理总结 - NSOperation详尽总结

1.NSOperation简介

2.NSOperation的创建

2.1NSInvocationOperation

2.2NSBlockOperation（最常用）

2.3自定义子类继承NSOperation，实现内部相应的方法

3.NSOperation的重要属性和方法

3.1依赖

3.2操作监听

3.3NSOperation的一些其他属性和方法

4NSOperationQueue的一些高级操作

4.1NSOperationQueue的重要属性和方法

4.1.1最大并发数

4.1.2线程的挂起

4.1.3取消队列里的所有操作

4.1.4依赖关系

4.2NSOperationQueue的一些其他属性和方法

5.NSOperation和NSOperationQueue结合使用创建多线程

6.NSOperation线程之间的通信

猜你喜欢

热点阅读