多线程(4)——NSOperation

2015-09-23 本文已影响98人海强_hq

本篇略长慎看

iOS中实现多线程的第四种方案--NSOperation

NSOperation实例封装了所需要执行的操作和执行操作所需的数据，并且能够以并发或者非并发的方式执行这个操作,配合使用NSOperation和NSOperationQueue也能实现多线程编程

NSOperation和NSOperationQueue实现多线程的具体步骤

先将需要执行的操作封装到一个NSOperation对象中
然后将NSOperation对象添加到NSOperationQueue中
系统会自动将NSOperationQueue中的NSOperation取出来
将取出的NSOperation封装的操作放到一条新线程中执行

NSOperation的基本使用

NSOperation是个抽象类，并不具备封装操作的能力，必须使用它的子类
使用NSOperation子类的3种方法

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

第一种:NSInvocationOperation的使用

    // 1.封装任务op1
    NSInvocationOperation *op1 = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(run) object:nil];

    // 2.要想执行任务必须调用start
    [op1 start];
    
    // 3.封装任务op2
    NSInvocationOperation *op2 = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(run2) object:nil];
    
    // 4.调用start
    [op2 start];

    // run方法
    - (void)run
    {
      // 打印当前线程
      NSLog(@"%@", [NSThread currentThread]);
    }

    // run2方法
    - (void)run2
    {
      // 打印当前线程
      NSLog(@"%@", [NSThread currentThread]);
    }

 // 打印结果
2015-09-22 23:44:10.203 NSOperation基本使用[1955:72948] <NSThread: 0x7fbc63c28690>{number = 1, name = main}
2015-09-22 23:44:10.204 NSOperation基本使用[1955:72948] <NSThread: 0x7fbc63c28690>{number = 1, name = main}

从打印结果可知，并没有开启新的线程，都是在主线程中执行

注意

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

第二种:NSBlockOperation的使用

    // 1. 封装任务
    NSBlockOperation *op1 = [NSBlockOperation blockOperationWithBlock:^{
        
         // 打印当前线程
        NSLog(@"1---%@", [NSThread currentThread]);
        
    }];
    
    // 2.追加其它任务
    [op1 addExecutionBlock:^{

        // 打印当前线程
        NSLog(@"2---%@", [NSThread currentThread]);
    }];
    [op1 addExecutionBlock:^{
        
        // 打印当前线程
        NSLog(@"3---%@", [NSThread currentThread]);
    }];
    
    // 3.启动任务
    [op1 start];

// 打印结果
2015-09-22 23:41:56.403 NSOperation基本使用[1925:71930] 2---<NSThread: 0x7fa868c01760>{number = 2, name = (null)}
2015-09-22 23:41:56.403 NSOperation基本使用[1925:71931] 3---<NSThread: 0x7fa868e7c7c0>{number = 3, name = (null)}
2015-09-22 23:41:56.403 NSOperation基本使用[1925:71822] 1---<NSThread: 0x7fa868f156b0>{number = 1, name = main}

注意: 在没有队列的情况下, 如果给BlockOperation追加其它任务, 那么其它任务会在子线程中执行,即只要NSBlockOperation封装的操作数 >1，就会异步执行操作

NSOperationQueue的基本使用

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

第1种：NSInvocationOperation添加到队列
只要是自己创建的队列, 就会在子线程中执行而且默认就是并发执行只要将任务添加到队列中, 队列会自动调用start

    // 1.创建队列
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];

    // 2.创建任务
    NSInvocationOperation *op1 = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(download1) object:nil];
    NSInvocationOperation *op2 = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(download2) object:nil];
    
    // 3.添加任务到队列中
    [queue addOperation:op1];
    [queue addOperation:op2];

    // download1方法
    - (void)download1
    {
        // 打印当前线程
        NSLog(@"1 == %@", [NSThread currentThread]);
    }

    // download2方法
    - (void)download2
    {
         // 打印当前线程
        NSLog(@"2 == %@", [NSThread currentThread]);
    }

 // 打印结果
2015-09-23 00:15:41.422 NSOperationQueue基本使用[2193:86087] 1 == <NSThread: 0x7fceb86515e0>{number = 3, name = (null)}
2015-09-23 00:15:41.422 NSOperationQueue基本使用[2193:86086] 2 == <NSThread: 0x7fceb849b400>{number = 2, name = (null)}

第2种：NSBlockOperation添加到队列

    // 1.创建队列
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];
    
    // 2.创建任务op1
    NSBlockOperation *op1 = [NSBlockOperation blockOperationWithBlock:^{

          // 打印当前线程
          NSLog(@"1 == %@", [NSThread currentThread]);
    }];
    
    // 3.创建任务op2
    NSBlockOperation *op2 = [NSBlockOperation blockOperationWithBlock:^{

         // 打印当前线程
        NSLog(@"2 == %@", [NSThread currentThread]);
    }];
    
    // 注意: 如果是使用block来封装任务, 那么有一种更简便的方法(快速添加任务的方法)
    // 只要利用队列调用addOperationWithBlock:方法, 系统内部会自动封装成一个NSBlockOperation然后再添加到队列中
    [queue addOperationWithBlock:^{

        // 打印当前线程
        NSLog(@"3 == %@", [NSThread currentThread]);
    }];
    
    // 4.添加任务到队列
    [queue addOperation:op1];
    [queue addOperation:op2];

// 打印结果
2015-09-23 00:24:41.488 NSOperationQueue基本使用[2258:89475] 2 == <NSThread: 0x7fc4c356b1b0>{number = 3, name = (null)}
2015-09-23 00:24:41.488 NSOperationQueue基本使用[2258:89474] 1 == <NSThread: 0x7fc4c356b230>{number = 4, name = (null)}
2015-09-23 00:24:41.488 NSOperationQueue基本使用[2258:89473] 3 == <NSThread: 0x7fc4c34167d0>{number = 2, name = (null)}

第3种：自定义任务添加到队列

自定义任务

#import <Foundation/Foundation.h>

@interface HQOperation : NSOperation

@end

#import "HQOperation.h"

@implementation HQOperation

/*
 只要将任务添加到队列中, 那么队列在执行自定义任务的时候
 就会自动调用main方法
 */
- (void)main
{
    NSLog(@"%s, %@", __func__, [NSThread currentThread]);
}

@end

创建并添加到队列

   // 1.创建队列
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];

    // 2.创建任务
    // 自定义任务的好处: 提高代码的复用性
    HQOperation *op1 = [[HQOperation alloc] init];
    HQOperation *op2 = [[HQOperation alloc] init];
    
    // 3.添加任务到队列
    [queue addOperation:op1];
    [queue addOperation:op2];

    // 打印结果
    2015-09-23 00:34:24.369 NSOperationQueue基本使用[2369:93788] -[XMGOperation main], <NSThread: 0x7f9db06067e0>{number = 3, name = (null)}
    2015-09-23 00:34:24.369 NSOperationQueue基本使用[2369:93790] -[XMGOperation main], <NSThread: 0x7f9db04247a0>{number = 2, name = (null)}

3种方案小结

自己创建队列: alloc init
会开启新的线程, 并在子线程中执行

GCD中有哪些队列: 并发: 自己创建, 全局串行: 自己创建, 主队列
NSOperationQueue: 主队列: mainQueue 自己创建: 会在子线程中执行

最大并发数

什么是并发数？
- 同时执行的任务数
- 比如，同时开3个线程执行3个任务，并发数就是3

// 最大并发数的相关方法
- (NSInteger)maxConcurrentOperationCount;
- (void)setMaxConcurrentOperationCount:(NSInteger)count;

如何控制并行和串行 maxConcurrentOperationCount = -1 ; 并行(默认就是并行) maxConcurrentOperationCount = 1 ; 串行 maxConcurrentOperationCount = 0 ; 不会执行

队列的暂停和恢复以及取消

暂停
- 注意点:暂停其实是暂停下一个任务, 而不能暂停当前任务

self.queue.suspended = YES;

恢复
- 注意点: 恢复之后会继续执行队列中没有被执行的操作

self.queue.suspended = NO;

取消
- 实现原理: 调用所有操作的cancel方法
- 注意点: 取消其实是取消下一个任务, 而不能取消当前任务
- 如果自定义操作中做了很多耗时操作, 官方建议定期检查是否已经取消了

[self.queue cancelAllOperations];

操作依赖

在操作添加到队列之前, 利用操作调用addDependency, 就快要添加依赖
添加依赖之后, 只有所有依赖的任务都执行完毕, 才会执行当前任务
注意点: 不要相互依赖
特点: 跨队列依赖(GCD默认是不支持)
NSOperation之间可以设置依赖来保证执行顺序比如一定要让操作A执行完后，才能执行操作B，可以这么写 // 操作B依赖于操作A [operationBaddDependency:operationA];

 // 1.创建队列
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];
    NSOperationQueue *queue2 = [[NSOperationQueue alloc] init];

    // 2.创建5个任务
    NSBlockOperation *op1 = [NSBlockOperation blockOperationWithBlock:^{
        
        // 打印当前线程
        NSLog(@"1-------%@", [NSThread currentThread]);
    }];
    
    NSBlockOperation *op2 = [NSBlockOperation blockOperationWithBlock:^{
        
        // 打印当前线程
        NSLog(@"2-------%@", [NSThread currentThread]);
    }];
    
    NSBlockOperation *op3 = [NSBlockOperation blockOperationWithBlock:^{
        
        // 打印当前线程
        NSLog(@"3-------%@", [NSThread currentThread]);
    }];
    
    NSBlockOperation *op4 = [NSBlockOperation blockOperationWithBlock:^{
        
        // 打印当前线程
        NSLog(@"4-------%@", [NSThread currentThread]);
        
        // 执行任务
        for (int i = 0; i < 5; i++) {
            NSLog(@"%i", i);
        }
    }];
    
    NSBlockOperation *op5 = [NSBlockOperation blockOperationWithBlock:^{
        
        // 打印当前线程
        NSLog(@"5-------%@", [NSThread currentThread]);
    }];
    
    
    // 3.添加依赖
    [op1 addDependency:op2];
    [op1 addDependency:op3];
    [op1 addDependency:op4];
    [op1 addDependency:op5];

    
    // 4.监听op4什么时候执行完毕
    op4.completionBlock = ^{
        NSLog(@"op4中所有的操作都执行完毕了");
    };
    
    // 5.添加任务到队列
    [queue addOperation:op1];
    [queue addOperation:op2];
    [queue2 addOperation:op3];
    [queue2 addOperation:op4];
    [queue addOperation:op5];

2015-09-23 01:08:56.270 NSOpreatinoQueue的其它常用方法[2675:107479] 3-------<NSThread: 0x7fc842d151f0>{number = 2, name = (null)}
2015-09-23 01:08:56.270 NSOpreatinoQueue的其它常用方法[2675:107480] 2-------<NSThread: 0x7fc842ea0840>{number = 5, name = (null)}
2015-09-23 01:08:56.270 NSOpreatinoQueue的其它常用方法[2675:107478] 5-------<NSThread: 0x7fc842f197c0>{number = 4, name = (null)}
2015-09-23 01:08:56.270 NSOpreatinoQueue的其它常用方法[2675:107477] 4-------<NSThread: 0x7fc842d15f20>{number = 3, name = (null)}
2015-09-23 01:08:56.271 NSOpreatinoQueue的其它常用方法[2675:107477] 0
2015-09-23 01:08:56.272 NSOpreatinoQueue的其它常用方法[2675:107477] 1
2015-09-23 01:08:56.272 NSOpreatinoQueue的其它常用方法[2675:107477] 2
2015-09-23 01:08:56.272 NSOpreatinoQueue的其它常用方法[2675:107477] 3
2015-09-23 01:08:56.272 NSOpreatinoQueue的其它常用方法[2675:107477] 4
2015-09-23 01:08:56.272 NSOpreatinoQueue的其它常用方法[2675:107478] op4中所有的操作都执行完毕了
2015-09-23 01:08:56.273 NSOpreatinoQueue的其它常用方法[2675:107478] 1-------<NSThread: 0x7fc842f197c0>{number = 4, name = (null)}

只有执行完其它4个任务和for循环之后才会执行op1任务

操作的监听

可以监听一个操作的执行完毕

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

只需要利用操作调用completionBlock即可
只要任务执行完毕, 就会回调completionBlock

线程间的通信

将任务添加到自己创建的队列中
再利用mainQueue回到主队列