##一、简介

###1、使用步骤

配合使用NSOperation和NSOperationQueue也能实现多线程编程

先将操作封装到一个NSOperation对象中
然后将NSOperation对象添加到NSOperationQueue中
系统会自动将NSOperationQueue中的NSOperation取出来
将取出的NSOperation封装的操作放到一条新线程中执行
###2、具体实现方法：

第一步：封装操作

封装操作的时候可以使用NSOperation的子类实现，因为NSOperation是抽象类，所以不能直接使用。

三种方式：

NSInvocationOperation
NSBlockOperation
自定义子类继承NSOperation，实现内部相应的方法
下面分别讲解三种方式：

1、NSInvocationOperation
创建NSInvocationOperation对象

- (id)initWithTarget:(id)target selector:(SEL)sel object:(id)arg;

调用start方法开始执行操作

- (void)start;
//一旦执行操作，就会调用target的sel方法

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

2、创建NSBlockOperation对象

+ (id)blockOperationWithBlock:(void (^)(void))block;

通过addExecutionBlock:方法添加更多的操作

- (void)addExecutionBlock:(void (^)(void))block;

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

3、自定义NSOperation
自定义NSOperation的步骤很简单
重写- (void)main方法，在里面实现想执行的任务
重写- (void)main方法的注意点：
自己创建自动释放池（因为如果是异步操作，无法访问主线程的自动释放池）
经常通过- (BOOL)isCancelled方法检测操作是否被取消，对取消做出响应
由于取消同样会继续执行当前正在执行的任务, 所以耗时操作需要手动判断是否已经取消

if (self.isCancelled) return;

第二步：添加任务奥队列中：
// 一般情况下, 在做企业开发时候,都会定义一个全局的自定义队列, 便于使用

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

NSOperationQueue的作用

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

- (void)addOperation:(NSOperation *)op;
- (void)addOperationWithBlock:(void (^)(void))block;

设置最大并发数

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

##3、队列的取消、暂停、恢复

- (void)cancelAllOperations;
// 取消队列中所有的任务的执行
// 取消和暂停一样, 是取消后面的任务, 不能取消当前正在执行的任务
// 注意: 取消是不可以恢复的

提示：也可以调用NSOperation的- (void)cancel方法取消单个操作
暂停和恢复队列

- (void)setSuspended:(BOOL)b;
// YES代表暂停队列，NO代表恢复队列
- (BOOL)isSuspended;
// 只要设置队列的suspended为YES, 那么就会暂停队列中其它任务的执行
// 也就是说不会再继续执行没有执行到得任务
// 只要设置队列的suspended为NO, 那么就会恢复队列中其它任务的执行
// 注意: 设置为暂停之后, 不会立即暂停
// 会继续执行当前正在执行的任务, 直到当前任务执行完毕, 就不会执行下一个任务了
// 也就是说, 暂停其实是暂停下一个任务, 而不能暂停当前任务
// 注意: 暂停是可以恢复的

##4、依赖

NSOperation之间可以设置依赖来保证执行顺序
比如一定要让操作A执行完后，才能执行操作B，可以这么写

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

可以在不同queue的NSOperation之间创建依赖关系

##5、任务操作的监听

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

- (void (^)(void))completionBlock;
- (void)setCompletionBlock:(void (^)(void))block;</code>

// 4.监听op4什么时候执行完毕
op4.completionBlock = ^{
    NSLog(@"op4中所有的操作都执行完毕了");
};

##具体使用介绍：
实例一：
NSBlockOperation简单使用，并添加任务

 //1. 封装任务
    NSBlockOperation *op1 = [NSBlockOperation blockOperationWithBlock:^{
        // 主线程
        NSLog(@"1---%@", [NSThread currentThread]);
    }];
    // 2.追加其它任务
    // 注意: 在没有队列的情况下, 如果给BlockOperation追加其它任务, 那么其它任务会在子线程中执行
    [op1 addExecutionBlock:^{
        NSLog(@"2---%@", [NSThread currentThread]);
    }];
    [op1 addExecutionBlock:^{
        NSLog(@"3---%@", [NSThread currentThread]);
    }];
    // 3.启动任务
    [op1 start];

实例二：

NSInvocationOperation的简单使用

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

实例三：

创建各种操作并添加到队列里面

// 1.创建队列
    /*
     GCD中有哪些队列:
     并发: 自己创建, 全局
     串行: 自己创建, 主队列
 
     NSOperationQueue:
     主队列: mainQueue
     自己创建: 会在子线程中执行
     */
 
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];
    // 2.创建任务
    // 只要是自己创建的队列, 就会在子线程中执行
    // 而且默认就是并发执行
    //第一种
    NSInvocationOperation *op1 = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(download1) object:nil];
    //第二种
    NSBlockOperation *op2 = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"2 == %@", [NSThread currentThread]);
    }];
 
    // 注意: 如果是使用block来封装任务, 那么有一种更简便的方法
    // 只要利用队列调用addOperationWithBlock:方法, 系统内部会自动封装成一个NSBlockOperation然后再添加到队列中
    //第三种
    [queue addOperationWithBlock:^{
        NSLog(@"3 == %@", [NSThread currentThread]);
    }];
 
 
    // 3.添加任务到队列中
    // 只要将任务添加到队列中, 队列会自动调用start
    [queue addOperation:op1];
    [queue addOperation:op2];

实例四：

最大执行数量

NSOperationQueue *queue = [[NSOperationQueue alloc] init];
// 自己创建的队列默认是并发,如果设置maxConcurrentOperationCount = 1,就是串行
// 注意: 不能设置为0, 如果设置为0就不行执行任务\
// 默认情况下maxConcurrentOperationCount = -1,是并行
// 在开发中并发数最多尽量不要超过5~6条
queue.maxConcurrentOperationCount = 0;

实例四：

线程间通讯

// 1.创建一个队列
    // 一般情况下, 在做企业开发时候, 都会定义一个全局的自定义队列, 便于使用
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];
 
    // 2.添加一个操作下载第一张图片
    __block UIImage *image1 = nil;
    NSBlockOperation *op1 = [NSBlockOperation blockOperationWithBlock:^{
        NSURL *url  = [NSURL URLWithString:@"http://imgcache.mysodao.com/img2/M04/8C/74/CgAPDk9dyjvS1AanAAJPpRypnFA573_700x0x1.JPG"];
        NSData *data = [NSData dataWithContentsOfURL:url];
        image1 = [UIImage imageWithData:data];
    }];
 
    // 3.添加一个操作下载第二张图片
    __block UIImage *image2 = nil;
     NSBlockOperation *op2 = [NSBlockOperation blockOperationWithBlock:^{
        NSURL *url  = [NSURL URLWithString:@"http://imgcache.mysodao.com/img1/M02/EE/B5/CgAPDE-kEtqjE8CWAAg9m-Zz4qo025-22365300.JPG"];
        NSData *data = [NSData dataWithContentsOfURL:url];
        image2 = [UIImage imageWithData:data];
    }];
    // 4.添加一个操作合成图片
    NSBlockOperation *op3 = [NSBlockOperation blockOperationWithBlock:^{
        UIGraphicsBeginImageContext(CGSizeMake(200, 200));
        [image1 drawInRect:CGRectMake(0, 0, 100, 200)];
        [image2 drawInRect:CGRectMake(100, 0, 100, 200)];
        UIImage *res = UIGraphicsGetImageFromCurrentImageContext();
        UIGraphicsEndImageContext();
 
        // 5.回到主线程更新UI
        [[NSOperationQueue mainQueue] addOperationWithBlock:^{
            self.imageView.image = res;
        }];
    }];
 
    // 6.添加依赖
 
    [op3 addDependency:op1];
    [op3 addDependency:op2];
 
    // 7.添加操作到队列中
    [queue addOperation:op1];
    [queue addOperation:op2];
    [queue addOperation:op3];