manbetx官方网站

多线程 – NSOperationiOS开发的多线程—NSOperation<五>

十月 14th, 2018  |  manbetx官方网站

1. NSOperation简介

NSOperation
是苹果提供于咱的均等法多线程解决方案。实际上NSOperation是依据GCD更胜似一层的卷入,但是比GCD更简明容易用、代码可读性也重强。

NSOperation需要相当NSOperationQueue来实现多线程。因为在默认情况下,NSOperation单独使用时系统共施行操作,并没开发新线程的力,只有NSOperationQueue才能实现异步执行。

NSOperation是因GCD的,那么用起来也和GCD差不多,其中,NSOperation相当给GCD中之任务,而NSOperationQueue则相当给GCD中的队列。NSOperation实现多线程的采用手续分为三步:

  • 开创任务:先用待实行的操作封装到一个NSOperation对象被;
  • 创办行:创建NSOperationQueue对象;
  • 以任务在到队中:然后用NSOperation对象上加到NSOperationQueue中。

然后,系统就是会见活动将NSOperationQueue中之NSOperation取出来,在初县城中实行操作。

– – – – – – – – –
下面我们来学下NSOperation和NSOperationQueue的核心采用 – – – – – – 

一、简介

NSOperation是苹果提供被我们的一致模仿多线程解决方案。实际上NSOperation是依据GCD更强一层的包装,但是正如GCD更简便好用、代码可读性也又胜。


NSOperation需要般配NSOperationQueue来实现多线程。因为默认情况下,NSOperation单独采取时系统一同实施操作,并从未开发新线程的力量,只有配合NSOperationQueue才能实现异步执行。

NSOperation实现多线程的施用手续分为三步:

  1. 创任务:先拿用实践的操作封装到一个NSOperation对象吃。
  2. 创立行:创建NSOperationQueue对象。
  3. 用任务在到行列中:然后拿NSOperation对象上加至NSOperationQueue中。

2. NSOperation的为主使用

二、使用

2.1 创建任务

NSOperation是个抽象类,并无可知封装任务。我们只有应用它的子类来封装任务,我们发出三栽艺术来封装任务。

a. 使用子类NSInvocationOperation

b. 以子类NSBlockOperation

c. 定义继承自NSOperation的子类,通过落实中相应的方法来封装任务。

当匪利用NSOperationQueue,单独采取NSOperation的情下网并施行操作,下面我们询问一下:

1、创建任务

NSOperation是只抽象类,并无克封装任务。我们只有用其的子类来封装任务。我们发三种植方法来封装任务。

运用子类NSInvocationOperation
行使子类NSBlockOperation
概念继承自NSOperation的子类,通过兑现中相应的方式来封装任务。
于非使NSOperationQueue,单独采取NSOperation的情状下网一同执行操作,下面我们学习以下任务之老三种创建方式。

//1.使用子类NSInvocationOperation
- (void)NSInvocationOperationUse{
    //在没有使用NSOperationQueue、单独使用NSInvocationOperation的情况下,NSInvocationOperation在主线程执行操作,并没有开启新线程。
    //1.创建NSInvocationOperation对象
    NSInvocationOperation *op = [[NSInvocationOperation alloc]initWithTarget:self selector:(@selector(runOp)) object:nil];
    //2.开始执行操作
    [op start];
}
- (void)runOp{
    NSLog(@"runOp------%@",[NSThread currentThread]);
}

图片 1

运作结果

//2.使用子类NSBlockOperationUse
- (void)NSBlockOperationUse{
    //NSBlockOperation提供了一个方法addExecutionBlock:,通过addExecutionBlock:就可以为NSBlockOperation添加额外的操作,这些额外的操作就会在其他线程并发执行。
    //1.创建NSBlockOperation对象
    NSBlockOperation *op = [NSBlockOperation blockOperationWithBlock:^{
        //主线程
        NSLog(@"NSBlockOperationUse------%@",[NSThread currentThread]);

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

    //2.开始执行操作
    [op start];
}

图片 2

运作结果

//3.定义继承自NSOperation的子类
- (void)NSOperationUse{
    //主线程
    ZQNSOperation *op = [[ZQNSOperation alloc]init];

    [op start];
}

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

@end

//ZQNSOperation.m 重新main方法
#import "ZQNSOperation.h"
@implementation ZQNSOperation
- (void)main{
    //任务
    for (int i = 0; i < 2; ++i) {
        NSLog(@"1-----%@",[NSThread currentThread]);
    }
}
@end

图片 3

运转结果

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.创立行

以及GCD中之面世队列、串行队列略有不同的凡:NSOperationQueue一共有些许栽队列:主队列、其他队。其中任何队同时富含了串行、并作功能。下边是主队列、其他队的主干创建方法与特点。

主队列
凡是长到主队列着之任务(NSOperation),都见面安放主线程遭遇执

NSOperationQueue *queue = [NSOperationQueue mainQueue];

旁队(非主队列)
加上到这种队列中之职责(NSOperation),就会见活动放到子线程中履行
再就是寓了:串行、并作功能

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

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是在新线程中执行的。

3.用任务添加到行列
- (void)NSInvocationOperationUse{

    //1.创建NSInvocationOperation对象
    NSInvocationOperation *op = [[NSInvocationOperation alloc]initWithTarget:self selector:(@selector(runOp)) object:nil];
    //2.创建NSBlockOperation
    NSBlockOperation *op2 = [NSBlockOperation blockOperationWithBlock:^{
        for (int i = 0; i < 2; ++i) {
            NSLog(@"1-----%@", [NSThread currentThread]);
        }
    }];
    //创建队列
    NSOperationQueue *queue = [[NSOperationQueue alloc]init];
    //2.开始执行操作
    [queue addOperation:op];
    [queue addOperation:op2];
}
- (void)runOp{
    NSLog(@"runOp------%@",[NSThread currentThread]);
}

图片 4

运作结果

足一直在block中增长任务,无需先创造

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

图片 5

运作结果

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的情景下,任务都是在主线程遭遇实践之,并从未开启新的线程。

4.串行 并行

极老并发数:maxConcurrentOperationCount
maxConcurrentOperationCount默认情况下啊-1,表示不进行限定,默认为并发执行。
当maxConcurrentOperationCount为1常常,进行串行执行,开启1条子线程。

当maxConcurrentOperationCount大于1时,进行并发执行,当然是价值不承诺超系统限制,即使自己安装一个要命老的价值,系统啊会活动调整。
maxConcurrentOperationCount为0,不执行队列任务。

 //创建队列
    NSOperationQueue *queue = [[NSOperationQueue alloc]init];
    //设置maxConcurrentOperationCount
    queue.maxConcurrentOperationCount = 2;
    //添加任务
    [queue addOperationWithBlock:^{
        NSLog(@"1-----%@", [NSThread currentThread]);

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

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

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

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

    }];

图片 6

运转结果

3. NSOperationQueue的中坚使用

以及GCD中之面世队列、串行队列略有不同的凡:NSOperationQueue
一共发生有限种植队列:主队列、其他队。其中任何队同时富含了串行、并作功能。下边是主队列、其他队的核心创建方法与特点。

– 主队列:

    凡是长到主队列着之职责(NSOperation),都见面坐主线程遭遇执

NSOperationQueue *queue = [NSOperationQueue mainQueue];

 – 其他队(非主队列)

    · 添加到这种队列中之天职(NSOperation),就会自行放到子线程中履行

    · 同时寓了:串行、并作功能

NSOperationQueue *queue = [[NSOperationQueue alloc] init];
5.操作依赖

例如有A、B两单操作,其中A执行了操作,B才会执行操作,那么就算需让B依赖让A。

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

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

    [op2 addDependency:op1];    //添加依赖关系,op2依赖于op1

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

图片 7

运转结果

 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)}

 我们好看看,都是于初的线程中实施的,并且是出新执行。

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时不时,任务是出现执行之,而且被线程数量是出于网控制的。

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。任务执行之相继,并无在于添加的一一,执行之一一取决于依赖。

7. 其他的法子

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

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

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

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

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

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

 注意:


这里的暂停与撤销并无意味可以用目前之操作就撤回,而是当当前底操作实施完毕后不复履行新的操作。


暂停和撤销的区别在:暂停操作下还得还原操作,继续为下执行;而撤回操作下,所有的操作就清空了,无法还接着执行剩下的操作。

相关文章

标签:,

Your Comments

近期评论

    功能


    网站地图xml地图