笔记-iOS 多线程：『NSOperation、NSOperationQueue』详尽总结
NSOperation、NSOperationQueue 简介
转载：行走少年郎数组
NSOperation、NSOperationQueue 是基于 GCD 更高一层的封装，因此也有相似的任务（操做） 和队列（操做队列） 的概念安全
-
操做（Operation）：bash
- 执行操做的意思，换句话说就是你在线程中执行的那段代码。
- 在 GCD 中是放在 block 中的。在 NSOperation 中，咱们使用 NSOperation 子类 NSInvocationOperation、NSBlockOperation，或者自定义子类来封装操做。
-
操做队列（Operation Queues）：多线程
- 这里的队列指操做队列，即用来存放操做的队列。不一样于 GCD 中的调度队列 FIFO（先进先出）的原则。NSOperationQueue 对于添加到队列中的操做，首先进入准备就绪的状态（就绪状态取决于操做之间的依赖关系），而后进入就绪状态的操做的开始执行顺序（非结束执行顺序）由操做之间相对的优先级决定（优先级是操做对象自身的属性）。
- 操做队列经过设置最大并发操做数（maxConcurrentOperationCount）来控制并发、串行。
- NSOperationQueue 为咱们提供了两种不一样类型的队列：主队列和自定义队列。主队列运行在主线程之上，而自定义队列在后台执行。
NSOperation、NSOperationQueue使用步骤
NSOperation须要配合NSOperationQueue来实现多线程。由于默认状况下，NSOperation单独使用时，系统同步执行操做，配合NSOperationQueue咱们能更好的实现异步执行。并发
NSOperation实现多线程通常分三步：异步
- 建立操做：先将须要执行的操做封装到一个
NSOperation对象中。 - 建立队列：建立
NSOperationQueue对象。 - 将操做加入到队列中：将
NSOperation对象添加到NSOperationQueue对象中。
以后，系统就会自动将NSOperationQueue中的NSOperation取出来，在新线程中执行操做。ui
NSOperation 和NSOperationQueue基本使用
建立操做
NSOperation是个抽象类，不能来封装操做。咱们只有使用它的子类来封装操做。atom
- 使用子类
NSInvocationOperation - 使用子类
NSBlockOperation - 自定义继承
NSOperation的子类，经过实现内部相应的方法来封装操做。
子类NSInvocationOperation
- (void)demo {
NSInvocationOperation *op = [[NSInvocationOperation alloc]initWithTarget:self selector:@selector(handleInvocation:) object:@"zuobian"];
// 注意: 若是该任务已经添加到队列,你再手动调回出错
NSOperationQueue *queue = [[NSOperationQueue alloc] init];
[queue addOperation:op];
// 若是就是在主线程中调用建议使用下面的方法执行
// [[NSOperationQueue mainQueue] addOperation:op]; // 推荐使用
// 手动调起操做,默认在当前线程
// [op start]; // 不推荐使用
}
复制代码
知识点：spa
- 在没有使用
NSOperationQueue、在主线程中单独使用使用子类NSInvocationOperation执行一个操做的状况下，操做是在当前线程执行的，并无开启新线程。 - 若是在其余线程中执行操做，则打印结果为其余线程。
子类NSBlockOperation
- (void)demo {
//1:建立blockOperation
NSBlockOperation *op = [NSBlockOperation blockOperationWithBlock:^{
NSLog(@"%@",[NSThread currentThread]);
for (int i = 0; i < 2; i++) {
[NSThread sleepForTimeInterval:2]; // 模拟耗时操做
NSLog(@"1---%@", [NSThread currentThread]); // 打印当前线程
}
}];
[op addExecutionBlock:^{
for (int i = 0; i < 2; i++) {
[NSThread sleepForTimeInterval:2]; // 模拟耗时操做
NSLog(@"2---%@", [NSThread currentThread]); // 打印当前线程
}
}];
//1.1 设置监听
op.completionBlock = ^{
NSLog(@"%@",[NSThread currentThread]);
NSLog(@"完成了!!!");
};
//2:建立队列
NSOperationQueue *queue = [[NSOperationQueue alloc] init];
//3:添加到队列
[queue addOperation:op];
// 异步致使这里先走
NSLog(@"--------------- 完成了!!!"); // 最早输出
}
复制代码
NSBlockOperation 还提供了一个方法 addExecutionBlock:，经过 addExecutionBlock: 就能够为 NSBlockOperation 添加额外的操做。这些操做（包括 blockOperationWithBlock 中的操做）能够在不一样的线程中同时（并发）执行。只有当全部相关的操做已经完成执行时，才视为完成。 若是添加的操做多的话，blockOperationWithBlock: 中的操做也可能会在其余线程（非当前线程）中执行，这是由系统决定的，并非说添加到 blockOperationWithBlock: 中的操做必定会在当前线程中执行。（可使用 addExecutionBlock: 多添加几个操做试试）。线程
知识点：
- 在没有使用
NSOperationQueue、在主线程中单独使用NSBlockOperation执行一个操做的状况下，操做是在当前线程执行的，并无开启新线程。 - 通常状况下，若是一个 NSBlockOperation 对象封装了多个操做。NSBlockOperation 是否开启新线程，取决于操做的个数。若是添加的操做的个数多，就会自动开启新线程。固然开启的线程数是由系统来决定的。
使用自定义继承自NSOperation的子类
咱们可使用自定义继承自 NSOperation 的子类。能够经过重写 main 或者 start 方法 来定义本身的 NSOperation 对象。重写main方法比较简单，咱们不须要管理操做的状态属性 isExecuting 和 isFinished。当 main 执行完返回的时候，这个操做就结束了。
// .h 文件
#import <Foundation/Foundation.h>
@interface ZBOperation : NSOperation
@end
// .m 文件
#import "ZBOperation.h"
@implementation ZBOperation
- (void)main {
if (!self.isCancelled) {
for (int i = 0; i < 2; i++) {
[NSThread sleepForTimeInterval:2];
NSLog(@"1---%@", [NSThread currentThread]);
}
}
}
@end
复制代码
使用的时候导入头文件便可
/**
* 使用自定义继承自 NSOperation 的子类
*/
- (void)useCustomOperation {
// 1.建立 ZBOperation 对象
ZBOperation *op = [[ZBOperation alloc] init];
// 2.调用 start 方法开始执行操做
[op start];
}
复制代码
在没有使用 NSOperationQueue、在主线程单独使用自定义继承自 NSOperation 的子类的状况下，是在主线程执行操做，并无开启新线程。
建立队列
NSOperationQueue 一共有两种队列：主队列、自定义队列。其中自定义队列同时包含了串行、并发功能。下边是主队列、自定义队列的基本建立方法和特色。
- 主队列
- 凡是添加到主队列中的操做，都会放到主线程中执行（注：不包括操做使用
addExecutionBlock:添加的额外操做，额外操做可能在其余线程执行）。
- 凡是添加到主队列中的操做，都会放到主线程中执行（注：不包括操做使用
// 主队列获取方法
NSOperationQueue *queue = [NSOperationQueue mainQueue];
复制代码
- 自定义队列（非主队列）
- 添加到这种队列中的操做，就会自动放到子线程中执行。
- 同时包含了：串行、并发功能。
// 自定义队列建立方法
NSOperationQueue *queue = [[NSOperationQueue alloc] init];
复制代码
将操做加入到队列中
上边咱们说到 NSOperation 须要配合 NSOperationQueue 来实现多线程。
那么咱们须要将建立好的操做加入到队列中去。总共有两种方法：
- (void)addOperation:(NSOperation *)op;- 须要先建立操做，再将建立好的操做加入到建立好的队列中去。
/**
* 使用 addOperation: 将操做加入到操做队列中
*/
- (void)addOperationToQueue {
// 1.建立队列
NSOperationQueue *queue = [[NSOperationQueue alloc] init];
// 2.建立操做
// 使用 NSInvocationOperation 建立操做1
NSInvocationOperation *op1 = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(task1) object:nil];
// 使用 NSInvocationOperation 建立操做2
NSInvocationOperation *op2 = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(task2) object:nil];
// 使用 NSBlockOperation 建立操做3
NSBlockOperation *op3 = [NSBlockOperation blockOperationWithBlock:^{
for (int i = 0; i < 2; i++) {
[NSThread sleepForTimeInterval:2]; // 模拟耗时操做
NSLog(@"3---%@", [NSThread currentThread]); // 打印当前线程
}
}];
[op3 addExecutionBlock:^{
for (int i = 0; i < 2; i++) {
[NSThread sleepForTimeInterval:2]; // 模拟耗时操做
NSLog(@"4---%@", [NSThread currentThread]); // 打印当前线程
}
}];
// 3.使用 addOperation: 添加全部操做到队列中
[queue addOperation:op1]; // [op1 start]
[queue addOperation:op2]; // [op2 start]
[queue addOperation:op3]; // [op3 start]
}
复制代码
使用 NSOperation 子类建立操做，并使用 addOperation: 将操做加入到操做队列后可以开启新线程，进行并发执行。
- (void)addOperationWithBlock:(void (^)(void))block;- 无需先建立操做，在
block中添加操做，直接将包含操做的block加入到队列中。
- 无需先建立操做，在
/**
* 使用 addOperationWithBlock: 将操做加入到操做队列中
*/
- (void)addOperationWithBlockToQueue {
// 1.建立队列
NSOperationQueue *queue = [[NSOperationQueue alloc] init];
// 2.使用 addOperationWithBlock: 添加操做到队列中
[queue addOperationWithBlock:^{
for (int i = 0; i < 2; i++) {
[NSThread sleepForTimeInterval:2]; // 模拟耗时操做
NSLog(@"1---%@", [NSThread currentThread]); // 打印当前线程
}
}];
[queue addOperationWithBlock:^{
for (int i = 0; i < 2; i++) {
[NSThread sleepForTimeInterval:2]; // 模拟耗时操做
NSLog(@"2---%@", [NSThread currentThread]); // 打印当前线程
}
}];
[queue addOperationWithBlock:^{
for (int i = 0; i < 2; i++) {
[NSThread sleepForTimeInterval:2]; // 模拟耗时操做
NSLog(@"3---%@", [NSThread currentThread]); // 打印当前线程
}
}];
}
复制代码
使用 addOperationWithBlock: 将操做加入到操做队列后可以开启新线程，进行并发执行。
NSOperationQueue 控制串行执行、并发执行
以前咱们说过，NSOperationQueue 建立的自定义队列同时具备串行、并发功能，上边咱们演示了并发功能，那么他的串行功能是如何实现的？
这里有个关键属性 maxConcurrentOperationCount，叫作最大并发操做数。用来控制一个特定队列中能够有多少个操做同时参与并发执行。
注意：这里
maxConcurrentOperationCount控制的不是并发线程的数量，而是一个队列中同时能并发执行的最大操做数。并且一个操做也并不是只能在一个线程中运行。
- 最大并发操做数：
maxConcurrentOperationCountmaxConcurrentOperationCount默认状况下为-1，表示不进行限制，可进行并发执行。maxConcurrentOperationCount为1时，队列为串行队列。只能串行执行。maxConcurrentOperationCount大于1时，队列为并发队列。操做并发执行，固然这个值不该超过系统限制，即便本身设置一个很大的值，系统也会自动调整为 min{本身设定的值，系统设定的默认最大值}。
当最大并发操做数为1时，操做是按顺序串行执行的，而且一个操做完成以后，下一个操做才开始执行。当最大操做并发数为2时，操做是并发执行的，能够同时执行两个操做。而开启线程数量是由系统决定的，不须要咱们来管理
NSOperation 操做依赖
NSOperation、NSOperationQueue最吸引人的地方是它能添加操做之间的依赖关系。经过操做依赖，咱们能够很方便的控制操做之间的执行前后顺序。NSOperation 提供了3个接口供咱们管理和查看依赖。
- (void)addDependency:(NSOperation *)op;添加依赖，使当前操做依赖于操做op的完成。- (void)removeDependency:(NSOperation *)op;移除依赖，取消当前操做对操做op的依赖。@property (readonly, copy) NSArray<NSOperation *> *dependencies;在当前操做开始执行以前完成执行的全部操做对象数组。
/**
* 操做依赖
* 使用方法：addDependency:
*/
- (void)addDependency {
// 1.建立队列
NSOperationQueue *queue = [[NSOperationQueue alloc] init];
// 2.建立操做
NSBlockOperation *op1 = [NSBlockOperation blockOperationWithBlock:^{
for (int i = 0; i < 2; i++) {
[NSThread sleepForTimeInterval:2]; // 模拟耗时操做
NSLog(@"1---%@", [NSThread currentThread]); // 打印当前线程
}
}];
NSBlockOperation *op2 = [NSBlockOperation blockOperationWithBlock:^{
for (int i = 0; i < 2; i++) {
[NSThread sleepForTimeInterval:2]; // 模拟耗时操做
NSLog(@"2---%@", [NSThread currentThread]); // 打印当前线程
}
}];
// 3.添加依赖
[op2 addDependency:op1]; // 让op2 依赖于 op1，则先执行op1，在执行op2
// 4.添加操做到队列中
[queue addOperation:op1];
[queue addOperation:op2];
}
复制代码
经过添加操做依赖，不管运行几回，其结果都是 op1 先执行，op2 后执行。
NSOperation 优先级
NSOperation 提供了queuePriority（优先级）属性，queuePriority属性适用于同一操做队列中的操做，不适用于不一样操做队列中的操做。默认状况下，全部新建立的操做对象优先级都是NSOperationQueuePriorityNormal。可是咱们能够经过setQueuePriority:方法来改变当前操做在同一队列中的执行优先级。
// 优先级的取值
typedef NS_ENUM(NSInteger, NSOperationQueuePriority) {
NSOperationQueuePriorityVeryLow = -8L,
NSOperationQueuePriorityLow = -4L,
NSOperationQueuePriorityNormal = 0,
NSOperationQueuePriorityHigh = 4,
NSOperationQueuePriorityVeryHigh = 8
};
复制代码
上边咱们说过：对于添加到队列中的操做，首先进入准备就绪的状态（就绪状态取决于操做之间的依赖关系），而后进入就绪状态的操做的开始执行顺序（非结束执行顺序）由操做之间相对的优先级决定（优先级是操做对象自身的属性）。
- 当一个操做的全部依赖都已经完成时，操做对象一般会进入准备就绪状态，等待执行。
举个例子，如今有4个优先级都是 NSOperationQueuePriorityNormal（默认级别）的操做：op1，op2，op3，op4。其中 op3 依赖于 op2，op2 依赖于 op1，即 op3 -> op2 -> op1。如今将这4个操做添加到队列中并发执行。
- 由于 op1 和 op4 都没有须要依赖的操做，因此在 op1，op4 执行以前，就是处于准备就绪状态的操做。
- 而 op3 和 op2 都有依赖的操做（op3 依赖于 op2，op2 依赖于 op1），因此 op3 和 op2 都不是准备就绪状态下的操做。
理解了进入就绪状态的操做，那么咱们就理解了queuePriority 属性的做用对象。
queuePriority属性决定了进入准备就绪状态下的操做之间的开始执行顺序。而且，优先级不能取代依赖关系。- 若是一个队列中既包含高优先级操做，又包含低优先级操做，而且两个操做都已经准备就绪，那么队列先执行高优先级操做。好比上例中，若是 op1 和 op4 是不一样优先级的操做，那么就会先执行优先级高的操做。
- 若是，一个队列中既包含了准备就绪状态的操做，又包含了未准备就绪的操做，未准备就绪的操做优先级比准备就绪的操做优先级高。那么，虽然准备就绪的操做优先级低，也会优先执行。优先级不能取代依赖关系。若是要控制操做间的启动顺序，则必须使用依赖关系。
NSOperation、NSOperationQueue 线程间的通讯
在 iOS 开发过程当中，咱们通常在主线程里边进行 UI 刷新，例如：点击、滚动、拖拽等事件。咱们一般把一些耗时的操做放在其余线程，好比说图片下载、文件上传等耗时操做。而当咱们有时候在其余线程完成了耗时操做时，须要回到主线程，那么就用到了线程之间的通信。
/**
* 线程间通讯
*/
- (void)communication {
// 1.建立队列
NSOperationQueue *queue = [[NSOperationQueue alloc]init];
// 2.添加操做
[queue addOperationWithBlock:^{
// 异步进行耗时操做
for (int i = 0; i < 2; i++) {
[NSThread sleepForTimeInterval:2]; // 模拟耗时操做
NSLog(@"1---%@", [NSThread currentThread]); // 打印当前线程
}
// 回到主线程
[[NSOperationQueue mainQueue] addOperationWithBlock:^{
// 进行一些 UI 刷新等操做
for (int i = 0; i < 2; i++) {
[NSThread sleepForTimeInterval:2]; // 模拟耗时操做
NSLog(@"2---%@", [NSThread currentThread]); // 打印当前线程
}
}];
}];
}
复制代码
NSOperation、NSOperationQueue 线程同步和线程安全
-
线程安全：若是你的代码所在的进程中有多个线程在同时运行，而这些线程可能会同时运行这段代码。若是每次运行结果和单线程运行的结果是同样的，并且其余的变量的值也和预期的是同样的，就是线程安全的。 若每一个线程中对全局变量、静态变量只有读操做，而无写操做，通常来讲，这个全局变量是线程安全的；如有多个线程同时执行写操做（更改变量），通常都须要考虑线程同步，不然的话就可能影响线程安全。
-
线程同步：可理解为线程 A 和 线程 B 一块配合，A 执行到必定程度时要依靠线程 B 的某个结果，因而停下来，示意 B 运行；B 依言执行，再将结果给 A；A 再继续操做。
举个简单例子就是：两我的在一块儿聊天。两我的不能同时说话，避免听不清(操做冲突)。等一我的说完(一个线程结束操做)，另外一个再说(另外一个线程再开始操做)。
下面，咱们模拟火车票售卖的方式，实现 NSOperation 线程安全和解决线程同步问题。 场景：总共有50张火车票，有两个售卖火车票的窗口，一个是北京火车票售卖窗口，另外一个是上海火车票售卖窗口。两个窗口同时售卖火车票，卖完为止。
非线程安全的状况代码：
/**
* 非线程安全：不使用 NSLock
* 初始化火车票数量、卖票窗口(非线程安全)、并开始卖票
*/
- (void)initTicketStatusNotSave {
NSLog(@"currentThread---%@",[NSThread currentThread]); // 打印当前线程
self.ticketSurplusCount = 50;
// 1.建立 queue1,queue1 表明北京火车票售卖窗口
NSOperationQueue *queue1 = [[NSOperationQueue alloc] init];
queue1.maxConcurrentOperationCount = 1;
// 2.建立 queue2,queue2 表明上海火车票售卖窗口
NSOperationQueue *queue2 = [[NSOperationQueue alloc] init];
queue2.maxConcurrentOperationCount = 1;
// 3.建立卖票操做 op1
NSBlockOperation *op1 = [NSBlockOperation blockOperationWithBlock:^{
[self saleTicketNotSafe];
}];
// 4.建立卖票操做 op2
NSBlockOperation *op2 = [NSBlockOperation blockOperationWithBlock:^{
[self saleTicketNotSafe];
}];
// 5.添加操做，开始卖票
[queue1 addOperation:op1];
[queue2 addOperation:op2];
}
/**
* 售卖火车票(非线程安全)
*/
- (void)saleTicketNotSafe {
while (1) {
if (self.ticketSurplusCount > 0) {
//若是还有票，继续售卖
self.ticketSurplusCount--;
NSLog(@"%@", [NSString stringWithFormat:@"剩余票数:%d 窗口:%@", self.ticketSurplusCount, [NSThread currentThread]]);
[NSThread sleepForTimeInterval:0.2];
} else {
NSLog(@"全部火车票均已售完");
break;
}
}
}
复制代码
能够看到： 在不考虑线程安全，不使用 NSLock 状况下，获得票数是错乱的，这样显然不符合咱们的需求，因此咱们须要考虑线程安全问题。
线程安全解决方案：能够给线程加锁，在一个线程执行该操做的时候，不容许其余线程进行操做。iOS 实现线程加锁有不少种方式。@synchronized、 NSLock、NSRecursiveLock、NSCondition、NSConditionLock、pthread_mutex、dispatch_semaphore、OSSpinLock、atomic(property) set/get等等各类方式。这里咱们使用 NSLock 对象来解决线程同步问题。NSLock 对象能够经过进入锁时调用 lock 方法，解锁时调用 unlock 方法来保证线程安全。
线程安全状况的代码：
/**
* 线程安全：使用 NSLock 加锁
* 初始化火车票数量、卖票窗口(线程安全)、并开始卖票
*/
- (void)initTicketStatusSave {
NSLog(@"currentThread---%@",[NSThread currentThread]); // 打印当前线程
self.ticketSurplusCount = 50;
self.lock = [[NSLock alloc] init]; // 初始化 NSLock 对象
// 1.建立 queue1,queue1 表明北京火车票售卖窗口
NSOperationQueue *queue1 = [[NSOperationQueue alloc] init];
queue1.maxConcurrentOperationCount = 1;
// 2.建立 queue2,queue2 表明上海火车票售卖窗口
NSOperationQueue *queue2 = [[NSOperationQueue alloc] init];
queue2.maxConcurrentOperationCount = 1;
// 3.建立卖票操做 op1
NSBlockOperation *op1 = [NSBlockOperation blockOperationWithBlock:^{
[self saleTicketSafe];
}];
// 4.建立卖票操做 op2
NSBlockOperation *op2 = [NSBlockOperation blockOperationWithBlock:^{
[self saleTicketSafe];
}];
// 5.添加操做，开始卖票
[queue1 addOperation:op1];
[queue2 addOperation:op2];
}
/**
* 售卖火车票(线程安全)
*/
- (void)saleTicketSafe {
while (1) {
// 加锁
[self.lock lock];
if (self.ticketSurplusCount > 0) {
//若是还有票，继续售卖
self.ticketSurplusCount--;
NSLog(@"%@", [NSString stringWithFormat:@"剩余票数:%d 窗口:%@", self.ticketSurplusCount, [NSThread currentThread]]);
[NSThread sleepForTimeInterval:0.2];
}
// 解锁
[self.lock unlock];
if (self.ticketSurplusCount <= 0) {
NSLog(@"全部火车票均已售完");
break;
}
}
}
复制代码
能够看出：在考虑了线程安全，使用 NSLock 加锁、解锁机制的状况下，获得的票数是正确的，没有出现混乱的状况。咱们也就解决了多个线程同步的问题。
NSOperation、NSOperationQueue 经常使用属性和方法概括
NSOperation 经常使用属性和方法
取消操做方法
- (void)cancel;可取消操做，实质是标记 isCancelled 状态。
判断操做状态方法
-
- (BOOL)isFinished;判断操做是否已经结束。 -
- (BOOL)isCancelled;判断操做是否已经标记为取消。 -
- (BOOL)isExecuting;判断操做是否正在在运行。 -
- (BOOL)isReady;判断操做是否处于准备就绪状态，这个值和操做的依赖关系相关。
操做同步
-
- (void)waitUntilFinished;阻塞当前线程，直到该操做结束。可用于线程执行顺序的同步。 -
- (void)setCompletionBlock:(void (^)(void))block;completionBlock会在当前操做执行完毕时执行completionBlock。 -
- (void)addDependency:(NSOperation *)op;添加依赖，使当前操做依赖于操做 op 的完成。 -
- (void)removeDependency:(NSOperation *)op;移除依赖，取消当前操做对操做 op 的依赖。 -
@property (readonly, copy) NSArray<NSOperation *> *dependencies;在当前操做开始执行以前完成执行的全部操做对象数组。
NSOperationQueue 经常使用属性和方法
取消/暂停/恢复操做
- (void)cancelAllOperations;能够取消队列的全部操做。- (BOOL)isSuspended;判断队列是否处于暂停状态。 YES 为暂停状态，NO 为恢复状态。- (void)setSuspended:(BOOL)b;可设置操做的暂停和恢复，YES 表明暂停队列，NO 表明恢复队列。
操做同步
- (void)waitUntilAllOperationsAreFinished;阻塞当前线程，直到队列中的操做所有执行完毕。
添加/获取操做`
- (void)addOperationWithBlock:(void (^)(void))block;向队列中添加一个NSBlockOperation类型操做对象。- (void)addOperations:(NSArray *)ops waitUntilFinished:(BOOL)wait;向队列中添加操做数组，wait标志是否阻塞当前线程直到全部操做结束- (NSArray *)operations;当前在队列中的操做数组（某个操做执行结束后会自动从这个数组清除）。- (NSUInteger)operationCount;当前队列中的操做数。
获取队列
+ (id)currentQueue;获取当前队列，若是当前线程不是在NSOperationQueue上运行则返回nil。+ (id)mainQueue;获取主队列。
注意： 一、这里的暂停和取消（包括操做的取消和队列的取消）并不表明能够将当前的操做当即取消，而是当当前的操做执行完毕以后再也不执行新的操做。 二、暂停和取消的区别就在于：暂停操做以后还能够恢复操做，继续向下执行；而取消操做以后，全部的操做就清空了，没法再接着执行剩下的操做。
- 1. iOS 多线程：『NSOperation、NSOperationQueue』详尽总结
- 2. iOS多线程：『NSOperation、NSOperationQueue』详尽总结
- 3. iOS 多线程 NSOperation、NSOperationQueue
- 4. iOS多线程之NSOperation、NSOperationQueue
- 5. 总结NSOperation、NSOperationQueue
- 6. iOS多线程开发-NSOperation/NSOperationQueue浅析
- 7. iOS多线程：『pthread、NSThread』详尽总结
- 8. iOS 多线程：『RunLoop』详尽总结
- 9. iOS 多线程：『GCD』详尽总结
- 10. iOS多线程：『GCD』详尽总结
- 更多相关文章...
- • C# 多线程 - C#教程
- • Spring体系结构详解 - Spring教程
- • Tomcat学习笔记（史上最全tomcat学习笔记）
- • 算法总结-回溯法
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. iOS 多线程：『NSOperation、NSOperationQueue』详尽总结
- 2. iOS多线程：『NSOperation、NSOperationQueue』详尽总结
- 3. iOS 多线程 NSOperation、NSOperationQueue
- 4. iOS多线程之NSOperation、NSOperationQueue
- 5. 总结NSOperation、NSOperationQueue
- 6. iOS多线程开发-NSOperation/NSOperationQueue浅析
- 7. iOS多线程：『pthread、NSThread』详尽总结
- 8. iOS 多线程：『RunLoop』详尽总结
- 9. iOS 多线程：『GCD』详尽总结
- 10. iOS多线程：『GCD』详尽总结