iOS开发>学无止境

作者：伯恩的遗产

网址：http://www.jianshu.com/p/0b0d9b1f1f19

点击“阅读原文”可查看本文网页版

NSOperation和NSOperationQueue

NSOperation 是苹果公司对 GCD 的封装，完全面向对象，所以使用起来更好理解。 大家可以看到 NSOperation 和 NSOperationQueue 分别对应 GCD 的 任务 和 队列 。操作步骤也很好理解：

1. 将要执行的任务封装到一个 NSOperation 对象中。

2. 将此任务添加到一个 NSOperationQueue 对象中。

然后系统就会自动在执行任务。至于同步还是异步、串行还是并行请继续往下看：

添加任务

值得说明的是，NSOperation 只是一个抽象类，所以不能封装任务。但它有 2 个子类用于封装任务。分别是：NSInvocationOperation 和 NSBlockOperation 。创建一个 Operation 后，需要调用 start 方法来启动任务，它会 默认在当前队列同步执行。当然你也可以在中途取消一个任务，只需要调用其 cancel 方法即可。

• NSInvocationOperation : 需要传入一个方法名。

 

OBJECTIVE-C

 

//1.创建NSInvocationOperation对象

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

//2.开始执行

[operation start];

 

SWIFT

 

在 Swift 构建的和谐社会里，是容不下 NSInvocationOperation 这种不是类型安全的败类的。苹果如是说。这里有相关解释

• NSBlockOperation

 

OBJECTIVE-C

//1.创建NSBlockOperation对象

NSBlockOperation *operation = [NSBlockOperation blockOperationWithBlock:^{

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

}];

//2.开始任务

[operation start];

SWIFT

//1.创建NSBlockOperation对象

let operation = NSBlockOperation { () -> Void in

println(NSThread.currentThread())

}

//2.开始任务

operation.start()

之前说过这样的任务，默认会在当前线程执行。但是 NSBlockOperation 还有一个方法：addExecutionBlock: ，通过这个方法可以给 Operation 添加多个执行 Block。这样 Operation 中的任务 会并发执行，它会 在主线程和其它的多个线程 执行这些任务，注意下面的打印结果：

OBJECTIVE-C

 

//1.创建NSBlockOperation对象

NSBlockOperation *operation = [NSBlockOperation blockOperationWithBlock:^{

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

}];

//添加多个Block

for (NSInteger i = 0; i < 5; i++) {

[operation addExecutionBlock:^{

NSLog(@"第%ld次：%@", i, [NSThread currentThread]);

}];

}

//2.开始任务

[operation start];

 

SWIFT

//1.创建NSBlockOperation对象

let operation = NSBlockOperation { () -> Void in

NSLog("%@", NSThread.currentThread())

}

//2.添加多个Block

for i in 0..<5 {

operation.addExecutionBlock { () -> Void in

NSLog("第%ld次 - %@", i, NSThread.currentThread())

}

}

//2.开始任务

operation.start()

打印输出

 

2015-07-28 17:50:16.585 test[17527:4095467] 第2次 - <NSThread: 0x7ff5c9701910>{number = 1, name = main}

2015-07-28 17:50:16.585 test[17527:4095666] 第1次 - <NSThread: 0x7ff5c972caf0>{number = 4, name = (null)}

2015-07-28 17:50:16.585 test[17527:4095665] <NSThread: 0x7ff5c961b610>{number = 3, name = (null)}

2015-07-28 17:50:16.585 test[17527:4095662] 第0次 - <NSThread: 0x7ff5c948d310>{number = 2, name = (null)}

2015-07-28 17:50:16.586 test[17527:4095666] 第3次 - <NSThread: 0x7ff5c972caf0>{number = 4, name = (null)}

2015-07-28 17:50:16.586 test[17527:4095467] 第4次 - <NSThread: 0x7ff5c9701910>{number = 1, name = main}

NOTE：addExecutionBlock 方法必须在 start() 方法之前执行，否则就会报错：

‘*** -[NSBlockOperation addExecutionBlock:]: blocks cannot be added after the operation has started executing or finished'

NOTE：大家可能发现了一个问题，为什么我在 Swift 里打印输出使用 NSLog() 而不是 println() 呢？原因是使用 print() / println() 输出的话，它会简单地使用 流（stream） 的概念，学过 C++ 的都知道。它会把需要输出的每个字符一个一个的输出到控制台。普通使用并没有问题，可是当多线程同步输出的时候问题就来了，由于很多 println() 同时打印，就会导致控制台上的字符混乱的堆在一起，而NSLog() 就没有这个问题。到底是什么样子的呢？你可以把上面 NSLog() 改为 println() ，然后一试便知。 更多 NSLog() 与 println() 的区别看这里

• 自定义Operation

除了上面的两种 Operation 以外，我们还可以自定义 Operation。自定义 Operation 需要继承 NSOperation 类，并实现其 main() 方法，因为在调用 start()方法的时候，内部会调用 main() 方法完成相关逻辑。所以如果以上的两个类无法满足你的欲望的时候，你就需要自定义了。你想要实现什么功能都可以写在里面。除此之外，你还需要实现 cancel() 在内的各种方法。所以这个功能提供给高级玩家，我在这里就不说了，等我需要用到时在研究它，到时候可能会再做更新。

创建队列

看过上面的内容就知道，我们可以调用一个 NSOperation 对象的 start() 方法来启动这个任务，但是这样做他们默认是 同步执行 的。就算是 addExecutionBlock 方法，也会在当前线程和其他线程 中执行，也就是说还是会占用当前线程。这是就要用到队列 NSOperationQueue 了。而且，按类型来说的话一共有两种类型：主队列、其他队列。只要添加到队列，会自动调用任务的 start() 方法

• 主队列

细心的同学就会发现，每套多线程方案都会有一个主线程（当然啦，说的是iOS中，像 pthread 这种多系统的方案并没有，因为 UI线程 理论需要每种操作系统自己定制）。这是一个特殊的线程，必须串行。所以添加到主队列的任务都会一个接一个地排着队在主线程处理。

//OBJECTIVE-C

NSOperationQueue *queue = [NSOperationQueue mainQueue];

//SWIFT

let queue = NSOperationQueue.mainQueue()

• 其他队列

因为主队列比较特殊，所以会单独有一个类方法来获得主队列。那么通过初始化产生的队列就是其他队列了，因为只有这两种队列，除了主队列，其他队列就不需要名字了。

注意：其他队列的任务会在其他线程并行执行。

OBJECTIVE-C

//1.创建一个其他队列

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

//2.创建NSBlockOperation对象

NSBlockOperation *operation = [NSBlockOperation blockOperationWithBlock:^{

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

}];

//3.添加多个Block

for (NSInteger i = 0; i < 5; i++) {

[operation addExecutionBlock:^{

NSLog(@"第%ld次：%@", i, [NSThread currentThread]);

}];

}

//4.队列添加任务

[queue addOperation:operation];

SWIFT

//1.创建其他队列

let queue = NSOperationQueue()

//2.创建NSBlockOperation对象

let operation = NSBlockOperation { () -> Void in

NSLog("%@", NSThread.currentThread())

}

//3.添加多个Block

for i in 0..<5 {

operation.addExecutionBlock { () -> Void in

NSLog("第%ld次 - %@", i, NSThread.currentThread())

}

}

//4.队列添加任务

queue.addOperation(operation)

打印输出

 

2015-07-28 20:26:28.463 test[18622:4443534] <NSThread: 0x7fd022c3ac10>{number = 5, name = (null)}

2015-07-28 20:26:28.463 test[18622:4443536] 第2次 - <NSThread: 0x7fd022e36d50>{number = 2, name = (null)}

2015-07-28 20:26:28.463 test[18622:4443535] 第0次 - <NSThread: 0x7fd022f237f0>{number = 4, name = (null)}

2015-07-28 20:26:28.463 test[18622:4443533] 第1次 - <NSThread: 0x7fd022d372b0>{number = 3, name = (null)}

2015-07-28 20:26:28.463 test[18622:4443534] 第3次 - <NSThread: 0x7fd022c3ac10>{number = 5, name = (null)}

2015-07-28 20:26:28.463 test[18622:4443536] 第4次 - <NSThread: 0x7fd022e36d50>{number = 2, name = (null)}

OK, 这时应该发问了，大家将 NSOperationQueue 与 GCD的队列 相比较就会发现，这里没有并行队列，那如果我想要10个任务在其他线程串行的执行怎么办？

这就是苹果封装的妙处，你不用管串行、并行、同步、异步这些名词。NSOperationQueue有一个参数 maxConcurrentOperationCount 最大并发数，用来设置最多可以让多少个任务同时执行。当你把它设置为 1 的时候，他不就是串行了嘛！

NSOperationQueue 还有一个添加任务的方法，- (void)addOperationWithBlock:(void (^)(void))block; ，这是不是和 GCD 差不多？这样就可以添加一个任务到队列中了，十分方便。

NSOperation 有一个非常实用的功能，那就是添加依赖。比如有 3 个任务：A: 从服务器上下载一张图片，B：给这张图片加个水印，C：把图片返回给服务器。这时就可以用到依赖了:

OBJECTIVE-C

 

//1.任务一：下载图片

NSBlockOperation *operation1 = [NSBlockOperation blockOperationWithBlock:^{

NSLog(@"下载图片 - %@", [NSThread currentThread]);

[NSThread sleepForTimeInterval:1.0];

}];

//2.任务二：打水印

NSBlockOperation *operation2 = [NSBlockOperation blockOperationWithBlock:^{

NSLog(@"打水印 - %@", [NSThread currentThread]);

[NSThread sleepForTimeInterval:1.0];

}];

//3.任务三：上传图片

NSBlockOperation *operation3 = [NSBlockOperation blockOperationWithBlock:^{

NSLog(@"上传图片 - %@", [NSThread currentThread]);

[NSThread sleepForTimeInterval:1.0];

}];

//4.设置依赖

[operation2 addDependency:operation1]; //任务二依赖任务一

[operation3 addDependency:operation2]; //任务三依赖任务二

//5.创建队列并加入任务

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

[queue addOperations:@[operation3, operation2, operation1] waitUntilFinished:NO];

SWIFT

 

//1.任务一：下载图片

let operation1 = NSBlockOperation { () -> Void in

NSLog("下载图片 - %@", NSThread.currentThread())

NSThread.sleepForTimeInterval(1.0)

}

//2.任务二：打水印

let operation2 = NSBlockOperation { () -> Void in

NSLog("打水印 - %@", NSThread.currentThread())

NSThread.sleepForTimeInterval(1.0)

}

//3.任务三：上传图片

let operation3 = NSBlockOperation { () -> Void in

NSLog("上传图片 - %@", NSThread.currentThread())

NSThread.sleepForTimeInterval(1.0)

}

//4.设置依赖

operation2.addDependency(operation1) //任务二依赖任务一

operation3.addDependency(operation2) //任务三依赖任务二

//5.创建队列并加入任务

let queue = NSOperationQueue()

queue.addOperations([operation3, operation2, operation1], waitUntilFinished: false)

打印结果

 

2015-07-28 21:24:28.622 test[19392:4637517] 下载图片 - <NSThread: 0x7fc10ad4d970>{number = 2, name = (null)}

2015-07-28 21:24:29.622 test[19392:4637515] 打水印 - <NSThread: 0x7fc10af20ef0>{number = 3, name = (null)}

2015-07-28 21:24:30.627 test[19392:4637515] 上传图片 - <NSThread: 0x7fc10af20ef0>{number = 3, name = (null)}

• 注意：不能添加相互依赖，会死锁，比如 A依赖B，B依赖A。

• 可以使用 removeDependency 来解除依赖关系。

• 可以在不同的队列之间依赖，反正就是这个依赖是添加到任务身上的，和队列没关系。

其他方法

以上就是一些主要方法, 下面还有一些常用方法需要大家注意：

• NSOperation

BOOL executing; //判断任务是否正在执行

BOOL finished; //判断任务是否完成

void (^completionBlock)(void); //用来设置完成后需要执行的操作

- (void)cancel; //取消任务

- (void)waitUntilFinished; //阻塞当前线程直到此任务执行完毕

• NSOperationQueue

NSUInteger operationCount; //获取队列的任务数

- (void)cancelAllOperations; //取消队列中所有的任务

- (void)waitUntilAllOperationsAreFinished; //阻塞当前线程直到此队列中的所有任务执行完毕

[queue setSuspended:YES]; // 暂停queue

[queue setSuspended:NO]; // 继续queue

好啦，到这里差不多就讲完了。当然，我讲的并不完整，可能有一些知识我并没有讲到，但作为常用方法，这些已经足够了。不过我在这里只是告诉你了一些方法的功能，只是怎么把他们用到合适的地方，就需要多多实践了。下面我会说一些关于多线程的案例，是大家更加什么地了解。

其他用法

在这部分，我会说一些和多线程知识相关的案例，可能有些很简单，大家早都知道的，不过因为这篇文章讲的是多线程嘛，所以应该尽可能的全面嘛。还有就是，我会尽可能的使用多种方法实现，让大家看看其中的区别。

线程同步

所谓线程同步就是为了防止多个线程抢夺同一个资源造成的数据安全问题，所采取的一种措施。当然也有很多实现方法，请往下看：

• 互斥锁 ：给需要同步的代码块加一个互斥锁，就可以保证每次只有一个线程访问此代码块。

 

OBJECTIVE-C

 

@synchronized(self) {

//需要执行的代码块

}

 

SWIFT

 

objc_sync_enter(self)

//需要执行的代码块

objc_sync_exit(self)

• 同步执行 ：我们可以使用多线程的知识，把多个线程都要执行此段代码添加到同一个串行队列，这样就实现了线程同步的概念。当然这里可以使用 GCD 和 NSOperation 两种方案，我都写出来。

OBJECTIVE-C

 

//GCD

//需要一个全局变量queue，要让所有线程的这个操作都加到一个queue中

dispatch_sync(queue, ^{

NSInteger ticket = lastTicket;

[NSThread sleepForTimeInterval:0.1];

NSLog(@"%ld - %@",ticket, [NSThread currentThread]);

ticket -= 1;

lastTicket = ticket;

});

//NSOperation & NSOperationQueue

//重点：1. 全局的 NSOperationQueue, 所有的操作添加到同一个queue中

// 2. 设置 queue 的 maxConcurrentOperationCount 为 1

// 3. 如果后续操作需要Block中的结果，就需要调用每个操作的waitUntilFinished，阻塞当前线程，一直等到当前操作完成，才允许执行后面的。waitUntilFinished 要在添加到队列之后！

NSBlockOperation *operation = [NSBlockOperation blockOperationWithBlock:^{

NSInteger ticket = lastTicket;

[NSThread sleepForTimeInterval:1];

NSLog(@"%ld - %@",ticket, [NSThread currentThread]);

ticket -= 1;

lastTicket = ticket;

}];

[queue addOperation:operation];

[operation waitUntilFinished];

//后续要做的事

SWIFT

 

这里的 swift 代码，我就不写了，因为每句都一样，只是语法不同而已，照着 OC 的代码就能写出 Swift 的。这篇文章已经老长老长了，我就不浪费篇幅了，又不是高中写作文。

延迟执行

所谓延迟执行就是延时一段时间再执行某段代码。下面说一些常用方法。

• perform

 

OBJECTIVE-C

 

// 3秒后自动调用self的run:方法，并且传递参数：@"abc"

[self performSelector:@selector(run:) withObject:@"abc" afterDelay:3];

SWIFT

 

之前就已经说过，Swift 里去掉了这个方法。

• GCD

可以使用 GCD 中的 dispatch_after 方法，OC 和 Swift 都可以使用，这里只写 OC 的，Swift 的是一样的。

OBJECTIVE-C

 

// 创建队列

dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

// 设置延时，单位秒

double delay = 3;

dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(delay * NSEC_PER_SEC)), queue, ^{

// 3秒后需要执行的任务

});

• NSTimer

NSTimer 是iOS中的一个计时器类，除了延迟执行还有很多用法，不过这里直说延迟执行的用法。同样只写 OC 版的，Swift 也是相同的。

OBJECTIVE-C

 

[NSTimer scheduledTimerWithTimeInterval:3.0 target:self selector:@selector(run:) userInfo:@"abc" repeats:NO]

单例模式

至于什么是单例模式，我也不多说，我只说说一般怎么实现。在 Objective-C 中，实现单例的方法已经很具体了，虽然有别的方法，但是一般都是用一个标准的方法了，下面来看看。

 

OBJECTIVE-C

 

@interface Tool : NSObject <NSCopying>

+ (instancetype)sharedTool;

@end

@implementation Tool

static id _instance;

+ (instancetype)sharedTool {

static dispatch_once_t onceToken;

dispatch_once(&onceToken, ^{

_instance = [[Tool alloc] init];

});

return _instance;

}

@end

这里之所以将单例模式，是因为其中用到了 GCD 的 dispatch_once 方法。下面看 Swift 中的单例模式，在Swift中单例模式非常简单！想知道怎么从 OC 那么复杂的方法变成下面的写法的，请看这里

SWIFT

 

class Tool: NSObject {

static let sharedTool = Tool()

// 私有化构造方法，阻止其他对象使用这个类的默认的'()'构造方法

private override init() {}

}

从其他线程回到主线程的方法

我们都知道在其他线程操作完成后必须到主线程更新UI。所以，介绍完所有的多线程方案后，我们来看看有哪些方法可以回到主线程。

• NSThread

//Objective-C

[self performSelectorOnMainThread:@selector(run) withObject:nil waitUntilDone:NO];

//Swift

//swift 取消了 performSelector 方法。

• GCD

//Objective-C

dispatch_async(dispatch_get_main_queue(), ^{

});

//Swift

dispatch_async(dispatch_get_main_queue(), { () -> Void in

})

• NSOperationQueue

//Objective-C

[[NSOperationQueue mainQueue] addOperationWithBlock:^{

}];

//Swift

NSOperationQueue.mainQueue().addOperationWithBlock { () -> Void in

}

总结

好的吧，总算写完了，纯手敲6k多字，感动死我了。花了两天，时间跨度有点大，所以可能有些地方上段不接下段或者有的地方不完整，如果你看着比较费力或者有什么地方有问题，都可以在评论区告诉我，我会及时修改的。当然啦，多线程的东西也不止这些，题目也就只是个题目，不要当真。想要了解更多的东西，还得自己去网上挖掘相关资料。多看看官方文档。实在是编不下去了，大家好好看~。对了，看我写的这么卖力，不打赏的话得点个喜欢也是极好的。

更新：第一次放出来的时候，有很多地方有错误，很感谢有朋友提出来了。如果你看到有错误的地方，一定记得指出来，这样对大家都有帮助。还有一点对初学者来说，遇到不懂的方法，最好的办法就是查看官方文档，那里是最准确的，就算有几个单词不认识，查一下就好了，不会影响对整体的理解。

我看到有网站转载了我的文章，但转载的可能存在问题，而我只能在简书上更新，所以如果要看 完整版本 还是到简书来看吧：这里是地址。