NSOperation 的使用,以及与GCD优缺点
NSOperation
文章目录
NSOperation简介
NSOperation和NSOperationQueue的基本使用
创建任务
创建队列
将任务加入到队列中
控制串行执行和并行执行的关键
操作依赖
一些其他方法
1. NSOperation简介
NSOperation是苹果提供给我们的一套多线程解决方案。实际上NSOperation是基于GCD更高一层的封装，但是比GCD更简单易用、代码可读性也更高。
NSOperation需要配合NSOperationQueue来实现多线程。因为默认情况下，NSOperation单独使用时系统同步执行操作，并没有开辟新线程的能力，只有配合NSOperationQueue才能实现异步执行。
因为NSOperation是基于GCD的，那么使用起来也和GCD差不多，其中，NSOperation相当于GCD中的任务，而NSOperationQueue则相当于GCD中的队列。NSOperation实现多线程的使用步骤分为三步：
1 .创建任务：先将需要执行的操作封装到一个NSOperation对象中。
2 .创建队列：创建NSOperationQueue对象。
3 .将任务加入到队列中：然后将NSOperation对象添加到NSOperationQueue中。
之后呢，系统就会自动将NSOperationQueue中的NSOperation取出来，在新线程中执行操作。
2.NSOperation和NSOperationQueue的基本使用
- 创建任务
NSOperation是个抽象类，并不能封装任务。我们只有使用它的子类来封装任务。我们有三种方式来封装任务。
使用子类NSInvocationOperation
使用子类NSBlockOperation
定义继承自NSOperation的子类，通过实现内部相应的方法来封装任务。
在不使用NSOperationQueue，单独使用NSOperation的情况下系统同步执行操作，下面我们学习以下任务的三种创建方式。
- 使用子类- NSInvocationOperation
// 使用子类- NSInvocationOperation:
- (void)NSInvocationOperationDemo{
// 1.创建NSInvocationOperation对象
NSInvocationOperation *op = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(run) object:nil];
// 2.调用start方法开始执行操作
[op start];
}
- (void)run
{
NSLog(@"当前的线程为--%@", [NSThread currentThread]);
}
运行结果如下:
当前的线程为--<NSThread: 0x60800007ff00>{number = 1, name = main}
从中可以看到，在没有使用NSOperationQueue、单独使用NSInvocationOperation的情况下，NSInvocationOperation在主线程执行操作，并没有开启新线程。
下边再来看看NSBlockOperation。
2 :使用子类-NSBlockOperation
// 使用 -NSBlockOperation
- (void)NSBlockOperationDemo{
NSBlockOperation *op = [NSBlockOperation blockOperationWithBlock:^{
NSLog(@"-当前的线程为-%@",[NSThread currentThread]);
}];
[op start];
}
结果如下:
-当前的线程为-<NSThread: 0x60800007cac0>{number = 1, name = main}
我们同样可以看到，在没有使用NSOperationQueue、单独使用NSBlockOperation的情况下，NSBlockOperation也是在主线程执行操作，并没有开启新线程。
3 :使用NSBlockOperation 的addExecutionBlock操作
// addExecutionBlock
- (void)blockOperation
{
NSBlockOperation *op = [NSBlockOperation blockOperationWithBlock:^{
// 在主线程
NSLog(@"1------%@", [NSThread currentThread]);
}];
// 添加额外的任务(在子线程执行)
[op addExecutionBlock:^{
NSLog(@"2------%@", [NSThread currentThread]);
}];
[op addExecutionBlock:^{
NSLog(@"3------%@", [NSThread currentThread]);
}];
[op addExecutionBlock:^{
NSLog(@"4------%@", [NSThread currentThread]);
}];
[op start];
}
可以看出，blockOperationWithBlock:方法中的操作是在主线程中执行的，而addExecutionBlock:方法中的操作是在其他线程中执行的。
1------<NSThread: 0x608000077f80>{number = 1, name = main}
3------<NSThread: 0x600000264600>{number = 3, name = (null)}
2------<NSThread: 0x6080002614c0>{number = 5, name = (null)}
4------<NSThread: 0x600000265780>{number = 4, name = (null)}
4. 定义继承自NSOperation的子类
先定义一个继承自NSOperation的子类，重写main方法
YSCOperation.h
#import <Foundation/Foundation.h>
@interface YSCOperation : NSOperation
@end
YSCOperation.m
#import "YSCOperation.h"
@implementation YSCOperation
/**
* 需要执行的任务
*/
- (void)main
{
for (int i = 0; i < 2; ++i) {
NSLog(@"--i---%@",[NSThread currentThread]);
}
}
@end
然后使用的时候导入头文件YSCOperation.h
// 创建YSCOperation
YSCOperation *op1 = [[YSCOperation alloc] init];
[op1 start];
运行后的输出结果如下:
--0---<NSThread: 0x6080000779c0>{number = 1, name = main}
--1---<NSThread: 0x6080000779c0>{number = 1, name = main}
可以看出：在没有使用NSOperationQueue、单独使用自定义子类的情况下，是在主线程执行操作，并没有开启新线程。
下边我们简单讲讲NSOperationQueue的创建。
2. 创建队列
和GCD中的并发队列、串行队列略有不同的是：NSOperationQueue一共有两种队列：主队列、其他队列。其中其他队列同时包含了串行、并发功能。下边是主队列、其他队列的基本创建方法和特点。
主队列
凡是添加到主队列中的任务（NSOperation），都会放到主线程中执行
NSOperationQueue *queue = [NSOperationQueue mainQueue];
其他队列（非主队列）
添加到这种队列中的任务（NSOperation），就会自动放到子线程中执行
同时包含了：串行、并发功能
NSOperationQueue *queue = [[NSOperationQueue alloc] init];
3. 将任务加入到队列中
前边说了，NSOperation需要配合NSOperationQueue来实现多线程。
那么我们需要将创建好的任务加入到队列中去。总共有两种方法
<1> :- (void)addOperation:(NSOperation *)op;
需要先创建任务，再将创建好的任务加入到创建好的队列中去
- (void)addOperationToQueue
{
// 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
{
for (int i = 0; i < 2; ++i) {
NSLog(@"2-----%@", [NSThread currentThread]);
}
}
运行结果如下:
2017-02-25 13:05:48.301 NSOperationDemo[1327:91464] 1--0p2---<NSThread: 0x608000066c80>{number = 3, name = (null)}
2017-02-25 13:05:48.301 NSOperationDemo[1327:91466] 2--op1---<NSThread: 0x6000000714c0>{number = 4, name = (null)}
2017-02-25 13:05:48.302 NSOperationDemo[1327:91464] 1--0p2---<NSThread: 0x608000066c80>{number = 3, name = (null)}
2017-02-25 13:05:48.302 NSOperationDemo[1327:91466] 2--op1---<NSThread: 0x6000000714c0>{number = 4, name = (null)}
可以看出：NSInvocationOperation和NSOperationQueue结合后能够开启新线程，进行并发执行NSBlockOperation和NSOperationQueue也能够开启新线程，进行并发执行
<2>: - (void)addOperationWithBlock:(void (^)(void))block;
无需先创建任务，在block中添加任务，直接将任务block加入到队列中。
- (void)addOperationWithBlockToQueue
{
// 1. 创建队列
NSOperationQueue *queue = [[NSOperationQueue alloc] init];
// 2. 添加操作到队列中：addOperationWithBlock:
[queue addOperationWithBlock:^{
for (int i = 0; i < 2; ++i) {
NSLog(@"-----%@", [NSThread currentThread]);
}
}];
}
输出结果如下:
输出结果：
2016-09-05 17:10:47.023 NSOperationQueue[16293:2457487] -----<NSThread: 0x7ffa6bc0e1e0>{number = 2, name = (null)}
2016-09-05 17:10:47.024 NSOperationQueue[16293:2457487] -----<NSThread: 0x7ffa6bc0e1e0>{number = 2, name = (null)}
可以看出addOperationWithBlock:和NSOperationQueue能够开启新线程，进行并发执行。
3. 控制串行执行和并行执行的关键
之前我们说过，NSOperationQueue创建的其他队列同时具有串行、并发功能，上边我们演示了并发功能，那么他的串行功能是如何实现的？
这里有个关键参数maxConcurrentOperationCount，叫做最大并发数。
最大并发数：maxConcurrentOperationCount
一定要在操作添加到队列之前设置操作之间的依赖，否则操作已经添加到队列中在设置依赖，依赖不会生效。
maxConcurrentOperationCount默认为-1，代表不限制。
问题：默认情况下，操作队列中的操作的执行顺序真的是无序的吗？
个人认为，默认情况下，操作队列中的操作执行顺序就是其被取出的顺序，也是其被添加到队列中的顺序，操作的执行顺序是有序的，但是操作执行完成的顺序是无序的。也就是说，因为不同的操作执行完成所需要的时间不同，最先从对垒中取出执行的操作不一定先执行完成，后执行的操作不一定后执行完成。所以，给人的感觉就是操作的执行是无序的。
其实，操作的依赖特性可以用GCD的信号量机制来实现。
当maxConcurrentOperationCount为1时，进行串行执行,就是操作的执行顺序和添加顺序是一致的
当maxConcurrentOperationCount大于1时，进行并发执行，当然这个值不应超过系统限制，即使自己设置一个很大的值，系统也会自动调整。
如果希望操作在主线程中执行，不要设置maxConcurrentOperationCount = 0。直接把操作添加到mainQueue中即可。
- (void)opetationQueue
{
// 创建队列
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];
}];
}
打印结果如下:
2017-02-25 13:17:00.942 NSOperationDemo[1455:99802] 1-----<NSThread: 0x600000262b80>{number = 3, name = (null)}
2017-02-25 13:17:00.955 NSOperationDemo[1455:99802] 2-----<NSThread: 0x600000262b80>{number = 3, name = (null)}
2017-02-25 13:17:00.966 NSOperationDemo[1455:99802] 3-----<NSThread: 0x600000262b80>{number = 3, name = (null)}
2017-02-25 13:17:00.977 NSOperationDemo[1455:99802] 4-----<NSThread: 0x600000262b80>{number = 3, name = (null)}
2017-02-25 13:17:00.989 NSOperationDemo[1455:99805] 5-----<NSThread: 0x60800026c280>{number = 4, name = (null)}
2017-02-25 13:17:01.001 NSOperationDemo[1455:99805] 6-----<NSThread: 0x60800026c280>{number = 4, name = (null)}
如果将 queue.maxConcurrentOperationCount = 2; // 就变成了并发队列,就是操作的执行顺序不会和添加的顺序不一样,
2017-02-25 13:19:54.141 NSOperationDemo[1482:102232] 2-----<NSThread: 0x60000006c2c0>{number = 4, name = (null)}
2017-02-25 13:19:54.141 NSOperationDemo[1482:102233] 1-----<NSThread: 0x608000077fc0>{number = 3, name = (null)}
2017-02-25 13:19:54.152 NSOperationDemo[1482:102235] 3-----<NSThread: 0x600000076000>{number = 5, name = (null)}
2017-02-25 13:19:54.152 NSOperationDemo[1482:102233] 4-----<NSThread: 0x608000077fc0>{number = 3, name = (null)}
2017-02-25 13:19:54.162 NSOperationDemo[1482:102232] 5-----<NSThread: 0x60000006c2c0>{number = 4, name = (null)}
2017-02-25 13:19:54.164 NSOperationDemo[1482:102233] 6-----<NSThread: 0x608000077fc0>{number = 3, name = (null)}
可以看出：当最大并发数为1时，任务是按顺序串行执行的。当最大并发数为2时，任务是并发执行的。queue.maxConcurrentOperationCount 的值越大,开启的线程会偏多,不过,开启线程数量是由系统决定的，当然这个值不应超过系统限制，即使自己设置一个很大的值，系统也会自动调整
4. 操作依赖
NSOperation和NSOperationQueue最吸引人的地方是它能添加操作之间的依赖关系。比如说有A、B两个操作，其中A执行完操作，B才能执行操作，那么就需要让B依赖于A。具体如下：
- (void)addDependency
{
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，则先执行op1，在执行op2
[queue addOperation:op1];
[queue addOperation:op2];
}
输出结果：
2016-09-05 17:51:28.811 操作依赖[16423:2484866] 1-----<NSThread: 0x7fc138e1e7c0>{number = 2, name = (null)}
2016-09-05 17:51:28.812 操作依赖[16423:2484866] 2-----<NSThread: 0x7fc138e1e7c0>{number = 2, name = (null)}
可以看到，无论运行几次，其结果都是op1先执行，op2后执行。
5. 一些其他方法
- (void)cancel;// NSOperation提供的方法，可取消单个操作
- (void)cancelAllOperations;// NSOperationQueue提供的方法，可以取消队列的所有操作
- (void)setSuspended:(BOOL)b;// 可设置任务的暂停和恢复，YES代表暂停队列，NO代表恢复队列
- (BOOL)isSuspended;// 判断暂停状态
注意：
这里的暂停和取消并不代表可以将当前的操作立即取消，而是当当前的操作执行完毕之后不再执行新的操作。
暂停和取消的区别就在于：暂停操作之后还可以恢复操作，继续向下执行；而取消操作之后，所有的操作就清空了，无法再接着执行剩下的操作。
6 .NSOperation优先级
GCD中，任务（block）是没有优先级的，而队列具有优先级。和GCD相反，我们一般考虑 NSOperation 的优先级
NSOperation 有一个NSOperationQueuePriority 枚举类型的属性 queuePriority
public enum NSOperationQueuePriority : Int {
case VeryLow
case Low
case Normal
case High
case VeryHigh
}
需要注意的是，NSOperationQueue 也不能完全保证优先级高的任务一定先执行。
queuePriority默认值是NSOperationQueuePriorityNormal。根据实际需要我们可以通过调用queuePriority的setter方法修改某个操作的优先级。
NSBlockOperation *blkop1 = [NSBlockOperation blockOperationWithBlock:^{
NSLog(@"执行blkop1");
}];
NSBlockOperation *blkop2 = [NSBlockOperation blockOperationWithBlock:^{
NSLog(@"执行blkop2");
}];
// 设置操作优先级
blkop1.queuePriority = NSOperationQueuePriorityLow;
blkop2.queuePriority = NSOperationQueuePriorityVeryHigh;
NSLog(@"blkop1 == %@",blkop1);
NSLog(@"blkop2 == %@",blkop2);
NSOperationQueue *queue = [[NSOperationQueue alloc] init];
// 操作添加到队列
[queue addOperation:blkop1];
[queue addOperation:blkop2];
NSLog(@"%@",[queue operations]);
for (NSOperation *op in [queue operations]) {
NSLog(@"op == %@",op);
}
// 输出结果：
2017-02-12 19:36:01.149 NSOperation[1712:177976] blkop1 == <NSBlockOperation: 0x608000044440>
2017-02-12 19:36:01.150 NSOperation[1712:177976] blkop2 == <NSBlockOperation: 0x6080000444d0>
2017-02-12 19:36:01.150 NSOperation[1712:177976] (
"<NSBlockOperation: 0x608000044440>",
"<NSBlockOperation: 0x6080000444d0>"
)
2017-02-12 19:36:01.150 NSOperation[1712:177976] op == <NSBlockOperation: 0x608000044440>
2017-02-12 19:36:01.150 NSOperation[1712:177976] op == <NSBlockOperation: 0x6080000444d0>
2017-02-12 19:36:01.150 NSOperation[1712:178020] 执行blkop1
2017-02-12 19:36:01.151 NSOperation[1712:178021] 执行blkop2
解析：
（1.）上面创建了两个blockOperation并且分别设置了优先级。显然blkop1的优先级低于blkop2的优先级。然后调用了队列的addOperation:方法使操作入队。最后输出结果证明，操作在对列中的顺去取决于addOperation:方法而不是优先级。
（2.）虽然blkop2优先级高于blkop1，但是bloop1却先于blkop2执行完成。所以，优先级高的操作不一定先执行完成。
注意：
（1.）优先级只能应用于相同queue中的operations。
（2.）操作的优先级高低不等于操作在队列中排列的顺序。换句话说，优先级高的操作不代表一定排在队列的前面。后入队的操作有可能因为优先级高而先被执行。PS:操作在队列中的顺序取决于队列的addOperation:方法。（证明代码如下）
（3.）优先级高只代表先被执行。不代表操作先被执行完成。执行完成的早晚还取决于操作耗时长短。
（4.）优先级不能替代依赖，优先级也绝不等于依赖。优先级只是对已经准备好的操作确定其执行顺序。
（5.）操作的执行优先满足依赖关系，然后再满足优先级。即先根据依赖执行操作，然后再从所有准备好的操作中取出优先级最高的那一个执行。
7 :waitUntilAllOperationsAreFinished
为了最佳的性能,你应该设计你的应用尽可能地异步操作，让应用在Operation正在执行时可以去处理其它事情。如果需要在当前线程中处理operation完成后的结果,可以使用NSOperation的waitUntilFinished方法阻塞当前线程，等待operation完成。通常我们应该避免编写这样的代码,阻塞当前线程可能是一种简便的解决方案,但是它引入了更多的串行代码,限制了整个应用的并发性,同时也降低了用户体验。绝对不要在应用主线程中等待一个Operation,只能在第二或次要线程中等待。阻塞主线程将导致应用无法响应用户事件,应用也将表现为无响应。
// 会阻塞当前线程，等到某个operation执行完毕
[operation waitUntilFinished];
除了等待单个Operation完成,你也可以同时等待一个queue中的所有操作,使用NSOperationQueue的waitUntilAllOperationsAreFinished方法。注意：在等待一个 queue时,应用的其它线程仍然可以往queue中添加Operation,因此可能会加长线程的等待时间。
// 阻塞当前线程，等待queue的所有操作执行完毕
[queue waitUntilAllOperationsAreFinished];
注意：waitUntilAllOperationsAreFinished一定要在操作队列添加了操作后再设置。即，先向operation queue中添加operation，再调用[operationQueue waitUntilAllOperationsAreFinished]。
NSBlockOperation *blkop = [NSBlockOperation blockOperationWithBlock:^{
NSLog(@"执行操作 %@",[NSThread currentThread]);
}];
NSOperationQueue *queue = [[NSOperationQueue alloc] init];
[queue addOperation:blkop];
// waitUntilAllOperationsAreFinished就像GCD的barrier一样起到隔离作用
// waitUntilAllOperationsAreFinished必须要在操作添加到队列后设置
// waitUntilAllOperationsAreFinished必须要在NSLog(@"finish");之前设置
waitUntilAllOperationsAreFinished
[queue waitUntilAllOperationsAreFinished];
NSLog(@"finish");
8 :GCD和nsoperation对比一下
<1>GCD
GCD是iOS4.0推出的，主要针对多核cpu做了优化，是C语言的技术
GCD是将任务(block)添加到队列(串行/并行/全局/主队列)，并且以同步/异步的方式执行任务的函数,任务的取出遵循队列的FIFO原则：先进先出，后进后出
GCD提供了一些NSOperation不具备的功能
一次性执行:可以保证某一段代码在程序运行的过程中只被执行一次;一次性执行是线程安全的,在多线程环境下也是只执行一次;应用场景:设计单例模式
延迟执行:既实现等待多长时间后在哪个队列中执行什么代码块
调度组:监听一组异步任务执行结束之后,我们能够得到统一的通知;注意:在其调度组内的任务执行完毕后执行后面的”刷新主界面”方法与”玩完”之间的执行没有先后顺序;例如:
dispatch_group_notify(group,dispatch_get_main_queue(), ^{
//更新UI控件，提示用户
NSLog(@"刷新主界面");
});
NSLog(@"玩完");
<2>NSOperation
NSOperation是iOS2.0推出的，iOS4.0之后重写了NSOperation
NSOperation将操作(异步的任务)添加到队列(并发队列)，就会执行指定操作的方法
NSOperation里提供的方便的操作
最大并发数,
队列的暂定/继续
取消队列中所有的操作
指定操作之间的依赖关系(GCD可以用同步实现,但是比较麻烦)
•同步和异步决定了要不要开启新的线程(同步不开,异步开)
同步：在当前线程中执行任务，不具备开启新线程的能力
异步：在新的线程中执行任务，具备开启新线程的能力
•串行和并发决定了任务的执行方式
并发：多个任务并发（同时）执行
串行：一个任务执行完毕后，再执行下一个任务
•当任务是异步的时候,队列决定了开启多少条线程
串行队列:只开一条
并发队列:可以开启多条
•主队列特点:主队列中的任务,只有主线程空闲的时候才会调度任务执行
主队列又叫全局串行队列,程序启动的时候就创建了主队列,在使用的时候不需要创建,直接GET.主队列中的任务是要在主线程执行的.
•主队列，异步任务
不开线程，同步执行
•主队列，同步执行
程序执行不出来（死锁）
死锁的原因，当程序执行到下面这段代码的时候
主队列：如果主线程正在执行代码，就不调度任务
同步执行：如果第一个任务没有执行，就继续等待第一个任务执行完成，再执行下一个任务此时互相等待，程序无法往下执行（死锁）
dispatch_sync(dispatch_get_main_queue(),^{
NSLog(@"%@ -- %d",[NSThreadcurrentThread],i);
});
•主队列和串行队列的区别
串行队列：必须等待一个任务执行完成，再调度另一个任务
主队列：以先进先出调度任务，如果主线程上有代码在执行，主队列不会调度任务
•（主队列，同步执行）放入异步执行解决死锁
dispatch_async(dispatch_get_global_queue(0,0), ^{
NSLog(@"全局队列，异步执行%@",[NSThread currentThread]);
//此时这行代码在子线程中运行，同步执行不用等待主线程执行此同步执行的任务
dispatch_sync(dispatch_get_main_queue(), ^{
NSLog(@"主队列,同步执行%@",[NSThread currentThread]);
});
NSLog(@"==");
});
•全局队列本质就是并发队列
dispatch_get_global_queue(0,0);
•全局队列和并发队列的区别
并发队列有名称，可以跟踪错误，全局队列没有
全局队列在ARC中不需要考虑释放内存，dispatch_release(q);不允许调用。并发队列在MRC中需要手动释放内存，因为并发队列是create创建出来的在MRC中见到create就要release，全局队列不需要release（只有一个）
一般我们使用全局队列,因为使用起来更加简单
<3>综合比较其各自使用范围如下
性能:①:GCD更接近底层，而NSOperationQueue则更高级抽象，所以GCD在追求性能的底层操作来说，是速度最快的。这取决于使用Instruments进行代码性能分析，如有必要的话
②:从异步操作之间的事务性，顺序行，依赖关系。GCD需要自己写更多的代码来实现，而NSOperationQueue已经内建了这些支持
③:如果异步操作的过程需要更多的被交互和UI呈现出来，NSOperationQueue会是一个更好的选择。底层代码中，任务之间不太互相依赖，而需要更高的并发能力，GCD则更有优势
