iOS多线程全套：线程生命周期，多线程的四种解决方案，线程安全问题，GCD的使用，NSOperation的使用（下）

7

NSOperation的理解与使用

No.1：NSOperation简介

NSOperation是基于GCD之上的更高一层封装，NSOperation需要配合NSOperationQueue来实现多线程。

NSOperation实现多线程的步骤如下：

1. 创建任务：先将需要执行的操作封装到NSOperation对象中。

2. 创建队列：创建NSOperationQueue。

3. 将任务加入到队列中：将NSOperation对象添加到NSOperationQueue中。

需要注意的是，NSOperation是个抽象类，实际运用时中需要使用它的子类，有三种方式：

• 使用子类NSInvocationOperation

• 使用子类NSBlockOperation

• 定义继承自NSOperation的子类，通过实现内部相应的方法来封装任务。

No.2：NSOperation的三种创建方式

NSInvocationOperation的使用

创建NSInvocationOperation对象并关联方法，之后start。

- (void)testNSInvocationOperation {

    // 创建NSInvocationOperation

    NSInvocationOperation *invocationOperation = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(invocationOperation) object:nil];

    // 开始执行操作

    [invocationOperation start];

}

- (void)invocationOperation {

    NSLog(@"NSInvocationOperation包含的任务，没有加入队列========%@", [NSThread currentThread]);

}

打印结果如下，得到结论：程序在主线程执行，没有开启新线程。

这是因为NSOperation多线程的使用需要配合队列NSOperationQueue，后面会讲到NSOperationQueue的使用。

NSInvocationOperation包含的任务，没有加入队列========{number = 1, name = main}

• NSBlockOperation的使用

把任务放到NSBlockOperation的block中，然后start。

- (void)testNSBlockOperation {

    // 把任务放到block中

    NSBlockOperation *blockOperation = [NSBlockOperation blockOperationWithBlock:^{

        NSLog(@"NSBlockOperation包含的任务，没有加入队列========%@", [NSThread currentThread]);

    }];

    [blockOperation start];

}

执行结果如下，可以看出：主线程执行，没有开启新线程。

同样的，NSBlockOperation可以配合队列NSOperationQueue来实现多线程。

NSBlockOperation包含的任务，没有加入队列========{number = 1, name = main}

但是NSBlockOperation有一个方法addExecutionBlock:，通过这个方法可以让NSBlockOperation实现多线程。

- (void)testNSBlockOperationExecution {

    NSBlockOperation *blockOperation = [NSBlockOperation blockOperationWithBlock:^{

        NSLog(@"NSBlockOperation运用addExecutionBlock主任务========%@", [NSThread currentThread]);

    }];

    [blockOperation addExecutionBlock:^{

        NSLog(@"NSBlockOperation运用addExecutionBlock方法添加任务1========%@", [NSThread currentThread]);

    }];

    [blockOperation addExecutionBlock:^{

        NSLog(@"NSBlockOperation运用addExecutionBlock方法添加任务2========%@", [NSThread currentThread]);

    }];

    [blockOperation addExecutionBlock:^{

        NSLog(@"NSBlockOperation运用addExecutionBlock方法添加任务3========%@", [NSThread currentThread]);

    }];

    [blockOperation start];

}

执行结果如下，可以看出，NSBlockOperation创建时block中的任务是在主线程执行，而运用addExecutionBlock加入的任务是在子线程执行的。

NSBlockOperation运用addExecutionBlock========{number = 1, name = main}

addExecutionBlock方法添加任务1========{number = 3, name = (null)}

addExecutionBlock方法添加任务3========{number = 5, name = (null)}

addExecutionBlock方法添加任务2========{number = 4, name = (null)}

• 运用继承自NSOperation的子类

首先我们定义一个继承自NSOperation的类，然后重写它的main方法，之后就可以使用这个子类来进行相关的操作了。

/*******************"WHOperation.h"*************************/

#import

@interface WHOperation : NSOperation

@end

/*******************"WHOperation.m"*************************/

#import "WHOperation.h"

@implementation WHOperation

- (void)main {

    for (int i = 0; i < 3; i++) {

        NSLog(@"NSOperation的子类WHOperation======%@",[NSThread currentThread]);

    }

}

@end

/*****************回到主控制器使用WHOperation**********************/

- (void)testWHOperation {

    WHOperation *operation = [[WHOperation alloc] init];

    [operation start];

}

运行结果如下，依然是在主线程执行。

SOperation的子类WHOperation======{number = 1, name = main}

NSOperation的子类WHOperation======{number = 1, name = main}

NSOperation的子类WHOperation======{number = 1, name = main}

所以，NSOperation是需要配合队列NSOperationQueue来实现多线程的。下面就来说一下队列NSOperationQueue。

No.3：队列NSOperationQueue

NSOperationQueue只有两种队列：主队列、其他队列。其他队列包含了串行和并发。

主队列的创建如下，主队列上的任务是在主线程执行的。

NSOperationQueue *mainQueue = [NSOperationQueue mainQueue];

其他队列（非主队列）的创建如下，加入到‘非队列’中的任务默认就是并发，开启多线程。

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

注意：

1. 非主队列（其他队列）可以实现串行或并行。

2. 队列NSOperationQueue有一个参数叫做最大并发数：maxConcurrentOperationCount。

3. maxConcurrentOperationCount默认为-1，直接并发执行，所以加入到‘非队列’中的任务默认就是并发，开启多线程。

4. 当maxConcurrentOperationCount为1时，则表示不开线程，也就是串行。

5. 当maxConcurrentOperationCount大于1时，进行并发执行。

6. 系统对最大并发数有一个限制，所以即使程序员把maxConcurrentOperationCount设置的很大，系统也会自动调整。所以把最大并发数设置的很大是没有意义的。

No.4：NSOperation + NSOperationQueue

把任务加入队列，这才是NSOperation的常规使用方式。

• addOperation添加任务到队列

先创建好任务，然后运用- (void)addOperation:(NSOperation *)op 方法来吧任务添加到队列中，示例代码如下：

- (void)testOperationQueue {

    // 创建队列，默认并发

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

    // 创建操作，NSInvocationOperation

    NSInvocationOperation *invocationOperation = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(invocationOperationAddOperation) object:nil];

    // 创建操作，NSBlockOperation

    NSBlockOperation *blockOperation = [NSBlockOperation blockOperationWithBlock:^{

        for (int i = 0; i < 3; i++) {

            NSLog(@"addOperation把任务添加到队列======%@", [NSThread currentThread]);

        }

    }];

    [queue addOperation:invocationOperation];

    [queue addOperation:blockOperation];

}

- (void)invocationOperationAddOperation {

    NSLog(@"invocationOperation===aaddOperation把任务添加到队列====%@", [NSThread currentThread]);

}

运行结果如下，可以看出，任务都是在子线程执行的，开启了新线程！

invocationOperation===addOperation把任务添加到队列===={number = 4, name = (null)}

addOperation把任务添加到队列======{number = 3, name = (null)}

addOperation把任务添加到队列======{number = 3, name = (null)}

addOperation把任务添加到队列======{number = 3, name = (null)}

• addOperationWithBlock添加任务到队列

这是一个更方便的把任务添加到队列的方法，直接把任务写在block中，添加到任务中。

- (void)testAddOperationWithBlock {

    // 创建队列，默认并发

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

    // 添加操作到队列

    [queue addOperationWithBlock:^{

        for (int i = 0; i < 3; i++) {

            NSLog(@"addOperationWithBlock把任务添加到队列======%@", [NSThread currentThread]);

        }

    }];

}

运行结果如下，任务确实是在子线程中执行。

addOperationWithBlock把任务添加到队列======{number = 3, name = (null)}

addOperationWithBlock把任务添加到队列======{number = 3, name = (null)}

addOperationWithBlock把任务添加到队列======{number = 3, name = (null)}

• 运用最大并发数实现串行

上面已经说过，可以运用队列的属性maxConcurrentOperationCount（最大并发数）来实现串行，值需要把它设置为1就可以了，下面我们通过代码验证一下。

- (void)testMaxConcurrentOperationCount {

    // 创建队列，默认并发

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

    // 最大并发数为1，串行

    queue.maxConcurrentOperationCount = 1;

    // 最大并发数为2，并发

//    queue.maxConcurrentOperationCount = 2;

    // 添加操作到队列

    [queue addOperationWithBlock:^{

        for (int i = 0; i < 3; i++) {

            NSLog(@"addOperationWithBlock把任务添加到队列1======%@", [NSThread currentThread]);

        }

    }];

    // 添加操作到队列

    [queue addOperationWithBlock:^{

        for (int i = 0; i < 3; i++) {

            NSLog(@"addOperationWithBlock把任务添加到队列2======%@", [NSThread currentThread]);

        }

    }];

    // 添加操作到队列

    [queue addOperationWithBlock:^{

        for (int i = 0; i < 3; i++) {

            NSLog(@"addOperationWithBlock把任务添加到队列3======%@", [NSThread currentThread]);

        }

    }];

}

运行结果如下，当最大并发数为1的时候，虽然开启了线程，但是任务是顺序执行的，所以实现了串行。

你可以尝试把上面的最大并发数变为2，会发现任务就变成了并发执行。

addOperationWithBlock把任务添加到队列1======{number = 3, name = (null)}

addOperationWithBlock把任务添加到队列1======{number = 3, name = (null)}

addOperationWithBlock把任务添加到队列1======{number = 3, name = (null)}

addOperationWithBlock把任务添加到队列2======{number = 3, name = (null)}

addOperationWithBlock把任务添加到队列2======{number = 3, name = (null)}

addOperationWithBlock把任务添加到队列2======{number = 3, name = (null)}

addOperationWithBlock把任务添加到队列3======{number = 3, name = (null)}

addOperationWithBlock把任务添加到队列3======{number = 3, name = (null)}

addOperationWithBlock把任务添加到队列3======{number = 3, name = (null)}

No.5：NSOperation的其他操作

• 取消队列NSOperationQueue的所有操作，NSOperationQueue对象方法

- (void)cancelAllOperations

取消NSOperation的某个操作，NSOperation对象方法

- (void)cancel

使队列暂停或继续

// 暂停队列

[queue setSuspended:YES];

判断队列是否暂停

- (BOOL)isSuspended

暂停和取消不是立刻取消当前操作，而是等当前的操作执行完之后不再进行新的操作。

No.6：NSOperation的操作依赖

NSOperation有一个非常好用的方法，就是操作依赖。可以从字面意思理解：某一个操作（operation2）依赖于另一个操作（operation1），只有当operation1执行完毕，才能执行operation2，这时，就是操作依赖大显身手的时候了。

- (void)testAddDependency {

    // 并发队列

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

    // 操作1

    NSBlockOperation *operation1 = [NSBlockOperation blockOperationWithBlock:^{

        for (int i = 0; i < 3; i++) {

            NSLog(@"operation1======%@", [NSThread  currentThread]);

        }

    }];

    // 操作2

    NSBlockOperation *operation2 = [NSBlockOperation blockOperationWithBlock:^{

        NSLog(@"****operation2依赖于operation1，只有当operation1执行完毕，operation2才会执行****");

        for (int i = 0; i < 3; i++) {

            NSLog(@"operation2======%@", [NSThread  currentThread]);

        }

    }];

    // 使操作2依赖于操作1

    [operation2 addDependency:operation1];

    // 把操作加入队列

    [queue addOperation:operation1];

    [queue addOperation:operation2];

}

运行结果如下，操作2总是在操作1之后执行，成功验证了上面的说法。

operation1======{number = 3, name = (null)}

operation1======{number = 3, name = (null)}

operation1======{number = 3, name = (null)}

****operation2依赖于operation1，只有当operation1执行完毕，operation2才会执行****

operation2======{number = 4, name = (null)}

operation2======{number = 4, name = (null)}

operation2======{number = 4, name = (null)}

• 本文所述的示例代码在这里：WHMultiThreadDemo

• 推荐简单又好用的分类集合：WHKit

• github地址：https://github.com/remember17

• iOS开发整理发布，转载请联系作者授权

↙点击“阅读原文”，加入 

『程序员大咖』

关注公众号：拾黑（shiheibook）了解更多

[广告]赞助链接：

四季很好，只要有你，文娱排行榜：https://www.yaopaiming.com/
让资讯触达的更精准有趣：https://www.0xu.cn/