NSOperation单独使用时系统同步施行操作,唯有NSOperationQueue才能落成异步执行

下面我们来学习下NSOperation和NSOperationQueue的基本使用 – – – – – – ,单独使用NSOperation的情况下系统同步执行操作

1. NSOperation简介

NSOperation
是苹果提需求我们的一套八线程消除方案。实际上NSOperation是依照GCD更高一层的包裹,但是比GCD更简约易用、代码可读性也更高。

NSOperation要求非凡NSOperationQueue来已毕多线程。因为在暗中同意情形下,NSOperation单独行使时系统同步施行操作,并从未开发新线程的能力,只有NSOperationQueue才能完结异步执行。

NSOperation是依照GCD的,那么使用起来也和GCD大概,其中,NSOperation约等于GCD中的职分,而NSOperationQueue则相当于GCD中的队列。NSOperation完毕四线程的采用手续分为三步:

  • 创办义务:先将索要举办的操作封装到1个NSOperation对象中;
  • 创建队列:创立NSOperationQueue对象;
  • 将职责加入到行列中:然后将NSOperation对象添加到NSOperationQueue中。

尔后,系统就会自动将NSOperationQueue中的NSOperation取出来,在中原区城中实施操作。

– – – – – – – – –
上面大家来学学下NSOperation和NSOperationQueue的主干使用 – – – – – – 

1. NSOperation简介

在一些意况下,执行后台义务GCD不自然是最好的情势,还有一种技术叫做操作队列NSOperationQueue.NSOperation是苹果提须求大家的一套八线程化解方案。实际上NSOperation是依照GCD更高一层的包装,可是比GCD更简便易行易用、代码可读性也更高。相对于GCD,使用NSOperation和NSOperationQueue有以下好处:

  • 撤回操作。运转职务之前可以在operation对象上进行cancel操作标识此任务不需执行
    ,若是是GCD,已经加入到行列的则无法裁撤了。
  • 指定操作间的依靠关系。
    贰个操作可以借助于其余多少个操作,比如一些操作必须在放手操作全体做到后才能起首。
  • KVO观看NSOperation对象的习性。NSOperation对象有丰富多的性格都契合用KVO来监听,比如isCancelled和isFinished属性。比如想在某些职务状态变更时收获关照,键值观测将相当管用。
  • 指定操作的事先级。GCD唯有队列才有优先级,而不是指向各个操作块来说的。
  • 任用NSOperation对象。系统内置了一些NSOperation的子类(比如NSBlockOperation),假若不想用那些本来的类,还是能自定义。那个类就是常常的OC对象,可以储存任何信息。

NSOperation须要般配NSOperationQueue来完结多线程。因为私行认同情状下,NSOperation单独行使时系统同步实施操作,并从未开发新线程的能力,只有协作NSOperationQueue才能完成异步执行。因为NSOperation是依据GCD的,那么使用起来也和GCD差不离,其中,NSOperation相当于GCD中的任务,而NSOperationQueue则也就是GCD中的队列。NSOperation完结多线程的采纳手续分为三步:

  1. 始建任务:先将急需实施的操作封装到三个NSOperation对象中。
  2. 开创队列:创制NSOperationQueue对象。
  3. 将任务参与到行列中:然后将NSOperation对象添加到NSOperationQueue中。
    之后呢,系统就会活动将NSOperationQueue中的NSOperation取出来,在新线程中推行操作。

2. NSOperation的主导采取

2 NSOperation和NSOperationQueue的宗旨采取

2.1 创立职分

NSOperation是个抽象类,并无法封装任务。我们唯有接纳它的子类来封装义务,我们有两种方式来封装任务。

a. 使用子类NSInvocationOperation

b. 使用子类NSBlockOperation

c. 定义继承自NSOperation的子类,通过达成内部相应的办法来封装任务。

在不使用NSOperationQueue,单独行使NSOperation的意况下系统同步施行操作,上面大家询问一下:

2.1 创立任务

NSOperation是个抽象类,并不能封装职责。大家只有利用它的子类来封装义务。我们有二种方法来封装职责。

  1. 利用子类NSInvocationOperation
  2. 运用子类NSBlockOperation
  3. 概念继承自NSOperation的子类,通过落到实处内部相应的艺术来封装任务。

在不采用NSOperationQueue,单独使用NSOperation的动静下系统一同施行操作,上面我们上学以下职务的三种创造形式。

2.2 使用子类NSInvocationOperation

// 1.创建NSInvocationOperation对象
NSInvocationOperation *operation = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(run) object:nil];

// 2.调用start方法开始执行操作
[op start];

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

 输出结果:

<NSThread: 0x604000260b00>{number = 1, name = main}

从中可以看看,在并未拔取NSOperationQueue,单独行使NSOperation的状态下,NSInvocationOperation是在脚下线程中举办操作,并从未创制新的线程。因为,当前线程是主线程,所以打印出的是主线程。

2.1.1 使用NSInvokeOpearion

- (IBAction)testInvokeOperation:(id)sender {
    // 1.创建NSInvocationOperation对象
    NSInvocationOperation *op = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(run) object:nil];

    // 2.调用start方法开始执行操作
    [op start];
}

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

出口结果:
2017-09-14 13:51:21.092 TestGCD[845:126221]
——testInvokeOperation:<NSThread: 0x17407abc0>{number = 1,
name = main}
单身采纳NSInvocationOperation的图景下,NSInvocationOperation在主线程执行操作,并没有打开新线程。

2.3 使用NSBlockOperation

NSBlockOperation *op = [NSBlockOperation blockOperationWithBlock:^{
    // 在主线程
    NSLog(@"------%@", [NSThread currentThread]);
}];

[op start];

输出结果:

<NSThread: 0x604000260b00>{number = 1, name = main}

 从中可以看看,在尚未应用NSOperationQueue,单独使用NSOperation的状态下,NSBlockOperation是在主线程中举行操作,并不曾成立新的线程。

不过NSBlockOperation还提供了二个方法
addExecutionBlock:,通过那几个方法就可以为NSBlockOperation添加额外的操作,这一个额外的操作就会在其他线程中并发执行。

输出结果

 NSOperation[1326:87276] 3 - <NSThread: 0x6000002715c0>{number = 4, name = (null)}
 NSOperation[1326:87282] 1 - <NSThread: 0x604000271780>{number = 3, name = (null)}
 NSOperation[1326:87200] <NSThread: 0x60000006c6c0>{number = 1, name = main}
 NSOperation[1326:87274] 2 - <NSThread: 0x6000002714c0>{number = 5, name = (null)}

 大家得以见见,任务都以出现执行的,NSBlockOperation中的职务是在主线程中进行的,addExecutionBlock是在新线程中推行的。

2.1.2 使用NSBlockOperation

- (IBAction)testBlockOperation:(id)sender {
    NSBlockOperation *op = [NSBlockOperation blockOperationWithBlock:^{
        // 在主线程
        NSLog(@"------testBlockOperation:%@", [NSThread currentThread]);
    }];

    [op start];
}

输出结果:
2017-09-14 13:48:00.326 TestGCD[845:126221]
——testBlockOperation:<NSThread: 0x17407abc0>{number = 1,
name = main}

单独采用NSBlockOperation的情状下,NSBlockOperation也是在主线程执行操作,并从未开启新线程。不过,NSBlockOperation还提供了二个措施addExecutionBlock:,通过addExecutionBlock:就可以为NSBlockOperation添加额外的操作,这一个额外的操作就会在其余线程并发执行。

- (IBAction)testBlockOperation:(id)sender {
    NSBlockOperation *op = [NSBlockOperation blockOperationWithBlock:^{
        // 在主线程
        NSLog(@"------testBlockOperation:%@", [NSThread currentThread]);
    }];

    // 添加额外的任务(在子线程执行)
    [op addExecutionBlock:^{
        NSLog(@"2------%@", [NSThread currentThread]);
    }];
    [op addExecutionBlock:^{
        NSLog(@"3------%@", [NSThread currentThread]);
    }];
    [op addExecutionBlock:^{
        NSLog(@"4------%@", [NSThread currentThread]);
    }];

    [op start];
}

输出结果:
2017-09-14 14:01:39.915 TestGCD[862:128404] 2——<NSThread:
0x170073640>{number = 3, name = (null)}
2017-09-14 14:01:39.915 TestGCD[862:128291]
——testBlockOperation:<NSThread: 0x17006d900>{number = 1,
name = main}
2017-09-14 14:01:39.919 TestGCD[862:128291] 4——<NSThread:
0x17006d900>{number = 1, name = main}
2017-09-14 14:01:39.919 TestGCD[862:128404] 3——<NSThread:
0x170073640>{number = 3, name = (null)}

可以看出,blockOperationWithBlock:方法中的操作是在主线程中执行的,而addExecutionBlock:方法中的操作是在任何线程中实施的。

2.4 自定义继承NSOperation的子类

WCEOperation.h

#import <Foundation/Foundation.h>

@interface WCEOperation : NSOperation

@end

 WCEOperation.m

#import "WCEOperation.h"

@implementation WCEOperation
// 需要执行的任务
-(void)main{
    for (NSInteger i = 0; i < 5; i++) {
        NSLog(@"%@",[NSThread currentThread]);
    }
}

@end

 在利用的时候,导入这么些文件

WCEOperation *operation = [[WCEOperation alloc] init];
[operation start];

 输出结果:

2017-12-11 22:53:42.126565+0800 NSOperation[1388:90762] <NSThread: 0x60400007fe40>{number = 1, name = main}
2017-12-11 22:53:42.126803+0800 NSOperation[1388:90762] <NSThread: 0x60400007fe40>{number = 1, name = main}
2017-12-11 22:53:42.126946+0800 NSOperation[1388:90762] <NSThread: 0x60400007fe40>{number = 1, name = main}
2017-12-11 22:53:42.127171+0800 NSOperation[1388:90762] <NSThread: 0x60400007fe40>{number = 1, name = main}
2017-12-11 22:53:42.127309+0800 NSOperation[1388:90762] <NSThread: 0x60400007fe40>{number = 1, name = main}

 大家得以看看,在并未利用NSOperationQueue的状态下,任务都以在主线程中进行的,并不曾拉开新的线程。

2.1.3 使用自定义的NSOperation

先定义贰个接续自NSOperation的子类,重写main方法

//  WYEOperation.h
#import <Foundation/Foundation.h>
@interface WYEOperation : NSOperation
@end

//  WYEOperation.m
#import "WYEOperation.h"
@implementation WYEOperation

- (void)main
{
    for (int i = 0; i < 2; ++i) {
        NSLog(@"1-----%@",[NSThread currentThread]);
    }
}
@end

- (IBAction)testWYEOperation:(id)sender {
    WYEOperation *op = [[WYEOperation alloc] init];
    [op start];
}

出口结果:
2017-09-14 14:27:51.905 TestGCD[885:131618] 1—–<NSThread:
0x17406dd00>{number = 1, name = main}
2017-09-14 14:27:51.908 TestGCD[885:131618] 1—–<NSThread:
0x17406dd00>{number = 1, name = main}

可以见到:在未曾拔取NSOperationQueue、单独采用自定义子类的动静下,是在主线程执行操作,并不曾拉开新线程。

3. NSOperationQueue的骨干采纳

和GCD中的并发队列、串行队列略有不一样的是:NSOperationQueue
一共有二种队列:主队列、其余队列。其中任何队列同时含有了串行、并发作用。下面是主队列、其余队列的为主创设方法和特色。

– 主队列:

    凡是添加到主队列中的职务(NSOperation),都会放到主线程中举行

NSOperationQueue *queue = [NSOperationQueue mainQueue];

 – 其余队列(非主队列)

    · 添加到那种队列中的义务(NSOperation),就会自行放到子线程中实施

    · 同时涵盖了:串行、并发功用

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

2.2 创建队列

和GCD中的并发队列、串行队列略有不一致的是:NSOperationQueue一共有二种队列:主队列、其他队列。其中任何队列同时涵盖了串行、并发功效。上边是主队列、其他队列的着力创造方法和特征。

  • 主队列。凡是添加到主队列中的职分(NSOperation),都会安放主线程中执行。

NSOperationQueue *queue = [NSOperationQueue mainQueue];
  • 其余队列。添加到那种队列中的义务(NSOperation),就会自行放到子线程中履行,同时含有了:串行、并发功效。

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

 4. 将职务出席到行列中

日前说了,NSOperation要求合营NSOperationQueue来落成四线程,那么我们须求将创造好的任务参与到行列中去,总共有三种办法:

a: – (void)addOperation:(NSOperation *)op;

须要先创建职分,再将创造好的义务参预到创设好的种类中去

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

    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]);
    }];
    NSBlockOperation *op5 = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"%@ - 5",[NSThread currentThread]);
    }];
    [opQueue addOperation:op1];
    [opQueue addOperation:op2];
    [opQueue addOperation:op3];
    [opQueue addOperation:op4];
    [opQueue addOperation:op5];

 运转结果:

2017-12-11 23:07:19.203418+0800 NSOperation[1468:97665] <NSThread: 0x60000046ac80>{number = 4, name = (null)} - 4
2017-12-11 23:07:19.203429+0800 NSOperation[1468:97664] <NSThread: 0x604000463300>{number = 6, name = (null)} - 1
2017-12-11 23:07:19.203439+0800 NSOperation[1468:97666] <NSThread: 0x60000046a980>{number = 5, name = (null)} - 2
2017-12-11 23:07:19.203867+0800 NSOperation[1468:97665] <NSThread: 0x60000046ac80>{number = 4, name = (null)} - 5
2017-12-11 23:07:19.204450+0800 NSOperation[1468:97667] <NSThread: 0x604000463280>{number = 3, name = (null)} - 3

 可以见见,NSOperation和NSOperationQueue结合后可以打开新线程,并发执行。

b. – (void)addOperationWithBlock:(void(^)void)block;

毋庸制造义务,在block中充裕义务,直接将任务block插足到行列中。

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

    [opQueue addOperationWithBlock:^{
        NSLog(@"1 - - %@",[NSThread currentThread]);
    }];
    [opQueue addOperationWithBlock:^{
        NSLog(@"2 - - %@",[NSThread currentThread]);
    }];
    [opQueue addOperationWithBlock:^{
        NSLog(@"3 - - %@",[NSThread currentThread]);
    }];
    [opQueue addOperationWithBlock:^{
        NSLog(@"4 - - %@",[NSThread currentThread]);
    }];
    [opQueue addOperationWithBlock:^{
        NSLog(@"5 - - %@",[NSThread currentThread]);
    }];

 运营结果:

2017-12-11 23:17:38.951881+0800 NSOperation[1510:102617] 2 - - <NSThread: 0x600000275400>{number = 4, name = (null)}
2017-12-11 23:17:38.951884+0800 NSOperation[1510:102615] 4 - - <NSThread: 0x6040004655c0>{number = 6, name = (null)}
2017-12-11 23:17:38.951889+0800 NSOperation[1510:102616] 1 - - <NSThread: 0x604000465540>{number = 3, name = (null)}
2017-12-11 23:17:38.951917+0800 NSOperation[1510:102619] 3 - - <NSThread: 0x604000465580>{number = 5, name = (null)}
2017-12-11 23:17:38.952182+0800 NSOperation[1510:102614] 5 - - <NSThread: 0x6000002754c0>{number = 7, name = (null)}

 大家可以看出,都以在新的线程中履行的,并且是出现执行。

2.3 将职责参与到行列中

前方说了,NSOperation需求分外NSOperationQueue来完毕二十四线程,那么大家需求将开创好的职务加入到行列中去。总共有二种办法:

5. 说了算串行执行和并行执行的重中之重

NSOperationQueue创设的其余队列同时具备串行、并发作用,上边突显了并发功效,那么她的串行功效是如何落到实处的?

此地就必要拔取一个第一参数:maxConcurrentOperationCount –
最大并发数。约等于最大并且推行的天职数,一般2-3,大于5自此,就算是在子线程中拍卖,但是cpu处理过多的子线程,也有或许影响主线程。

  • 暗许景况下为 -1,表示不开展限定,暗中认可为并发执行
  • 当maxConcurrentOperationCount为1时,进行串行执行。
  • 当maxConcurrentOperationCount大于1时,进行并发执行,当然这一个值不应当先系统限制,否则就是自个儿设置一个很大的值,系统也会活动调整。

仍旧刚刚那多少个例子,我们只设置NSOperationQueue的最大并发数为1

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

    opQueue.maxConcurrentOperationCount = 1;

    [opQueue addOperationWithBlock:^{
        NSLog(@"1 - - %@",[NSThread currentThread]);
    }];
    [opQueue addOperationWithBlock:^{
        NSLog(@"2 - - %@",[NSThread currentThread]);
    }];
    [opQueue addOperationWithBlock:^{
        NSLog(@"3 - - %@",[NSThread currentThread]);
    }];
    [opQueue addOperationWithBlock:^{
        NSLog(@"4 - - %@",[NSThread currentThread]);
    }];
    [opQueue addOperationWithBlock:^{
        NSLog(@"5 - - %@",[NSThread currentThread]);
    }];

 输出结果:

2017-12-11 23:22:30.824859+0800 NSOperation[1535:105237] 1 - - <NSThread: 0x600000275cc0>{number = 3, name = (null)}
2017-12-11 23:22:30.825228+0800 NSOperation[1535:105238] 2 - - <NSThread: 0x600000275d00>{number = 4, name = (null)}
2017-12-11 23:22:30.825614+0800 NSOperation[1535:105238] 3 - - <NSThread: 0x600000275d00>{number = 4, name = (null)}
2017-12-11 23:22:30.826585+0800 NSOperation[1535:105250] 4 - - <NSThread: 0x6000002756c0>{number = 5, name = (null)}
2017-12-11 23:22:30.826851+0800 NSOperation[1535:105250] 5 - - <NSThread: 0x6000002756c0>{number = 5, name = (null)}

 可以看到,当最大并发数为1的时候,职务是按顺序串行执行的,当最大并发数为2时,职分是出新执行的,而且打开线程数量是由系统控制的。

2.3.1 addOperation。要求先创设义务,再将创立好的职分参预到开创好的行列中去。

- (IBAction)testAddOperationQueue:(id)sender {
    // 1.创建队列
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];

    // 2. 创建操作
    // 创建NSInvocationOperation
    NSInvocationOperation *op1 = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(run) object:nil];
    // 创建NSBlockOperation
    NSBlockOperation *op2 = [NSBlockOperation blockOperationWithBlock:^{
        for (int i = 0; i < 2; ++i) {
            NSLog(@"1-----%@", [NSThread currentThread]);
        }
    }];

    // 3. 添加操作到队列中:addOperation:
    [queue addOperation:op1]; // [op1 start]
    [queue addOperation:op2]; // [op2 start]
}

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

出口结果:
2017-09-14 16:00:45.429 TestGCD[987:145817] 1—–<NSThread:
0x17007fc40>{number = 4, name = (null)}
2017-09-14 16:00:45.430 TestGCD[987:145806] ——run:<NSThread:
0x17007f280>{number = 3, name = (null)}
2017-09-14 16:00:45.433 TestGCD[987:145817] 1—–<NSThread:
0x17007fc40>{number = 4, name = (null)}

可以看来:NSInvocationOperation和NSOperationQueue结合后可以打开新线程,举行并发执行NSBlockOperation和NSOperationQueue也可以打开新线程,进行并发执行。

6. 操作倚重

NSOperation和NSOperationQueue最吸引认得地点是它能充分操作之间的依赖性关系。比如有A和B八个操作,其中A执行完操作,B才能实施操作,那么就需求让B倚重于A:

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

    NSBlockOperation *opA = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"我是opA,我先执行 - %@",[NSThread currentThread]);
    }];

    NSBlockOperation *opB = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"我是opB,我后执行 - %@",[NSThread currentThread]);
    }];

    [opB addDependency:opA];

    [opQueue addOperation:opB];
    [opQueue addOperation:opA];

 输出结果:

2017-12-11 23:31:23.494225+0800 NSOperation[1569:109435] 我是opA,我先执行 - <NSThread: 0x604000079ec0>{number = 3, name = (null)}
2017-12-11 23:31:23.494688+0800 NSOperation[1569:109434] 我是opB,我后执行 - <NSThread: 0x60000046f2c0>{number = 4, name = (null)}

 可以看出,无论运转五回,其结果都以opA先举办,opB后举办。注意:无法opA依赖opB,同时opB着重opA。职分履行的各种,并不在于添加的逐条,执行的逐条取决于正视。

2.3.2 addOperationWithBlock。无需先成立职分,在block中增加任务,直接将职务block出席到行列中。

- (IBAction)testAddOperationBlock:(id)sender {
    // 1. 创建队列
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];

    // 2. 添加操作到队列中:addOperationWithBlock:
    [queue addOperationWithBlock:^{
        for (int i = 0; i < 2; ++i) {
            NSLog(@"-----%@", [NSThread currentThread]);
        }
    }];
}

出口结果:
2017-09-14 16:23:30.031 TestGCD[1023:149967] —–<NSThread:
0x17406dd00>{number = 3, name = (null)}
2017-09-14 16:23:30.033 TestGCD[1023:149967] —–<NSThread:
0x17406dd00>{number = 3, name = (null)}

可以看出addOperationWithBlock:和NSOperationQueue可以打开新线程,举办并发执行。

7. 其余的艺术

// NSOperation提供的方法,可取消单个操作
- (void)cancel;

// NSOperationQueue提供的方法,可以取消队列的所有操作
- (void)cancelAllOperations;

// 可以设置任务的暂停和恢复,YES代表暂停队列,No表示恢复队列。
- (void)setSuspended:(BOOL)b;

// 判断暂停状态
- (BOOL)isSuspended;

// 设置操作优先级 优先级越高,被调用的几率越大

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

 注意:


那里的中断和取消并不意味可以将眼下的操作立刻裁撤,而是当当前的操作实施达成后不再实施新的操作。


暂停和注销的界别在于:暂停操作之后还是可以復苏操作,继续向下执行;而撤回操作之后,所有的操作就清空了,不能再跟着执行剩下的操作。

3 控制串行执行和并行执行的紧要

此前说过,NSOperationQueue创造的其余队列同时兼有串行、并发成效,上面大家演示了并发作用,那么她的串行成效是怎样达成的?那里有个主要参数maxConcurrentOperationCount,叫做最大并发数。

  • maxConcurrentOperationCount暗中认同情状下为-1,表示不开展界定,私行认同为并发执行。
  • 当maxConcurrentOperationCount为1时,进行串行执行。
  • 当maxConcurrentOperationCount大于1时,举办并发执行,当然那一个值不应当先系统限制,即便本身设置三个很大的值,系统也会自行调整。
    可以看如下示例:

- (IBAction)testMaxConcurrent:(id)sender {
    // 创建队列
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];

    // 设置最大并发操作数
        queue.maxConcurrentOperationCount = 2;
//    queue.maxConcurrentOperationCount = 1; // 就变成了串行队列

    // 添加操作
    [queue addOperationWithBlock:^{
        NSLog(@"1-----%@", [NSThread currentThread]);
        [NSThread sleepForTimeInterval:0.01];
    }];
    [queue addOperationWithBlock:^{
        NSLog(@"2-----%@", [NSThread currentThread]);
        [NSThread sleepForTimeInterval:0.01];
    }];
    [queue addOperationWithBlock:^{
        NSLog(@"3-----%@", [NSThread currentThread]);
        [NSThread sleepForTimeInterval:0.01];
    }];
    [queue addOperationWithBlock:^{
        NSLog(@"4-----%@", [NSThread currentThread]);
        [NSThread sleepForTimeInterval:0.01];
    }];
    [queue addOperationWithBlock:^{
        NSLog(@"5-----%@", [NSThread currentThread]);
        [NSThread sleepForTimeInterval:0.01];
    }];

    [queue addOperationWithBlock:^{
        NSLog(@"6-----%@", [NSThread currentThread]);
        [NSThread sleepForTimeInterval:0.01];
    }];
}

当最大并发数为1时,职责是按顺序串行执行的。当最大并发数为2时,职分是出新执行的。而且打开线程数量是由系统控制的,不须要大家来管理。

4 操作看重

NSOperation和NSOperationQueue最吸引人的地点是它能拉长操作之间的借助关系。比如说有A、B多个操作,其中A执行完操作,B才能实施操作,那么就要求让B器重于A。具体如下:

- (IBAction)testDependency:(id)sender {
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];

    NSBlockOperation *op1 = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"1-----%@", [NSThread  currentThread]);
    }];
    NSBlockOperation *op2 = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"2-----%@", [NSThread  currentThread]);
    }];

    [op1 addDependency:op2];    // 让op2 依赖于 op1,则先执行op1,在执行op2

    [queue addOperation:op1];
    [queue addOperation:op2];
}

输出结果:
2017-09-14 16:42:40.910 TestGCD[1065:153434] 2—–<NSThread:
0x17026cc40>{number = 3, name = (null)}
2017-09-14 16:42:40.914 TestGCD[1065:153434] 1—–<NSThread:
0x17026cc40>{number = 3, name = (null)}

随便运转四回,都以2在1事先运营。

5 其余艺术

- (void)cancel;    //NSOperation提供的方法,可取消单个操作
- (void)cancelAllOperations;     //NSOperationQueue提供的方法,可以取消队列的所有操作
- (void)setSuspended:(BOOL)b;     //可设置任务的暂停和恢复,YES代表暂停队列,NO代表恢复队列
- (BOOL)isSuspended;     //判断暂停状态

留意:那里的中止和废除并不意味着可以将日前的操作立即收回,而是当当前的操作实施已毕之后不再履行新的操作。
停顿和收回的分别就在于:暂停操作之后还足以恢复生机操作,继续向下实施;而撤回操作之后,所有的操作就清空了,不可以再接着执行剩下的操作。

6 参考资料

iOS三多线程–彻底学会四线程之『NSOperation』