iOS_GCD的零零总总
1、主线程队列 VS 分线程队列
dispatch_sync 和 dispatch_async 区别：
dispatch_async(queue,block) async 异步队列，dispatch_async 函数会立即返回, block会在后台异步执行。
dispatch_sync(queue,block) sync 同步队列，dispatch_sync 函数不会立即返回，及阻塞当前线程,等待 block同步执行完成。
// 分线程下载图片刷新主界面的例子
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
NSURL * url = [NSURL URLWithString:@"http://image.baidu.com/*****.jpg"];
NSData * data = [[NSData alloc] initWithContentsOfURL:url];
UIImage *image = [[UIImage alloc]initWithData:data];
if (data != nil) {
dispatch_async(dispatch_get_main_queue(), ^{
self.imageView.image = image;
});
}
});
主线程和分线程均是按照队列的方式进行运行，UI操作均是在主线程；
是不是每个非UI操作都需要放进分线程？——每个线程都需要CPU内存等额外的开销，线程越多，额外开销越多，代码设计成本越高风险越大，所以尽可能只把预计或者实际会占用很多时间的操作放入分线程，如算法遍历处理、网络IO、文件IO、图片数据处理等、数据库IO。
2、串行队列和并行队列
// 串行队列
dispatch_queue_t queue = dispatch_queue_create("com.example.MyQueue", DISPATCH_QUEUE_SERIAL);
// 并行队列
dispatch_queue_t queue = dispatch_queue_create("com.example.MyQueue", DISPATCH_QUEUE_CONCURRENT);
// 系统默认有一条并行队列
dispatch_queue_t globalQ = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
// 系统默认有一条串行队列
dispatch_queue_t mainQ = dispatch_get_main_queue();
串行队列就是单条线程中，任务挨个处理，主线程本身就是串行队列，一条铁路多个火车排队走。
并行队列就是多条线程，多个任务同时处理，多条铁轨多个火车同时走。
队列和线程关系？队列是线程+逻辑控制的集合，队列可以比作一个火车站，控制所有待发火车的顺序和走哪条铁轨，线程就是其中一条铁轨。一个队列可以有一个或者多个线程。
3、私有队列和全局队列
// 私有队列
dispatch_queue_t queue = dispatch_queue_create("com.example.MyQueue", NULL);
#define DISPATCH_QUEUE_SERIAL NULL
#define DISPATCH_QUEUE_CONCURRENT
// 全局队列有且唯一，统一调度，优化资源
dispatch_queue_t globalQ = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
// 并行队列优先级
#define DISPATCH_QUEUE_PRIORITY_HIGH 2
#define DISPATCH_QUEUE_PRIORITY_DEFAULT 0
#define DISPATCH_QUEUE_PRIORITY_LOW (-2)
#define DISPATCH_QUEUE_PRIORITY_BACKGROUND INT16_MIN
// 关于global_queue函数原型和flags必须为0的官方解释
* @param flags
* Reserved for future use. Passing any value other than zero may result in
* a NULL return value.
*/
dispatch_queue_t
dispatch_get_global_queue(long identifier, unsigned long flags);
4、使用队列
// 提交一个block
dispatch_async(queue, ^{
// do something......
// callback main_queue if needed
dispatch_async(dispatch_get_main_queue(), ^{
// refresh UI......
});
});
通常的，无特殊要求的，分线程一律采用global_queue统一调度,优先级无特殊要求的采用Default即可。所谓的优先级分配是指待分配任务中高优先级先行，而对于已进入线程的任务，不会受到后续任务的优先级影响。
dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
5、组任务
1）dispatch_group_async
可以实现监听一组任务是否完成，完成后得到通知执行其他的操作。这个方法很有用，比如你执行三个下载任务，当三个任务都下载完成后你才通知界面说完成的了。下面是一段例子代码：
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_group_t group = dispatch_group_create();
dispatch_group_async(group, queue, ^{
[NSThread sleepForTimeInterval:6];
NSLog(@"group1 [NSThread sleepForTimeInterval:6];");
});
dispatch_group_async(group, queue, ^{
[NSThread sleepForTimeInterval:3];
NSLog(@"group2 [NSThread sleepForTimeInterval:3];");
});
dispatch_group_async(group, queue, ^{
[NSThread sleepForTimeInterval:1];
NSLog(@"group3 [NSThread sleepForTimeInterval:1];");
});
dispatch_group_notify(group, dispatch_get_main_queue(), ^{
NSLog(@"main thread.");
});
}
执行结果为：
2013-07-24 16:48:23.063 NSThreadAndBlockDemo[2004:12e03] group3 [NSThread sleepForTimeInterval:1];
2013-07-24 16:48:25.063 NSThreadAndBlockDemo[2004:12b03] group2 [NSThread sleepForTimeInterval:3];
2013-07-24 16:48:28.063 NSThreadAndBlockDemo[2004:12303] group1 [NSThread sleepForTimeInterval:6];
2013-07-24 16:48:28.065 NSThreadAndBlockDemo[2004:11303] main thread.
2）dispatch_barrier_async
dispatch_barrier_async是在前面的任务执行结束后它才执行，而且它后面的任务等它执行完成之后才会执行，例子代码如下：
dispatch_queue_t queue = dispatch_queue_create("gcdtest.rongfzh.yc", DISPATCH_QUEUE_CONCURRENT);
dispatch_async(queue, ^{
[NSThread sleepForTimeInterval:3];
NSLog(@"dispatch_async1");
});
dispatch_async(queue, ^{
[NSThread sleepForTimeInterval:1];
NSLog(@"dispatch_async2");
});
dispatch_barrier_async(queue, ^{
NSLog(@"dispatch_barrier_async");
[NSThread sleepForTimeInterval:0.5];
});
dispatch_async(queue, ^{
[NSThread sleepForTimeInterval:1];
NSLog(@"dispatch_async3");
});
执行结果为：
2013-07-24 17:01:54.580 NSThreadAndBlockDemo[2153:12b03] dispatch_async2
2013-07-24 17:01:56.580 NSThreadAndBlockDemo[2153:12303] dispatch_async1
2013-07-24 17:01:56.580 NSThreadAndBlockDemo[2153:12303] dispatch_barrier_async
2013-07-24 17:01:58.083 NSThreadAndBlockDemo[2153:12303] dispatch_async3
如果使用dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);会发现运行结果为：
2013-07-24 17:07:17.577 NSThreadAndBlockDemo[2247:12e03] dispatch_barrier_async
2013-07-24 17:07:18.579 NSThreadAndBlockDemo[2247:15207] dispatch_async3
2013-07-24 17:07:19.578 NSThreadAndBlockDemo[2247:12b03] dispatch_async2
2013-07-24 17:07:20.577 NSThreadAndBlockDemo[2247:12303] dispatch_async1
说明dispatch_barrier_async的顺序执行还是依赖queue的类型啊，必需要queue的类型为dispatch_queue_create创建的，而且attr参数值必需是DISPATCH_QUEUE_CONCURRENT类型，前面两个非dispatch_barrier_async的类型的执行是依赖其本身的执行时间的，如果attr如果是DISPATCH_QUEUE_SERIAL时，那就完全是符合Serial queue的FIFO特征了。
3）dispatch_group_enter，dispatch_group_leave
自己创建队列时，当然就用dispatch_group_async函数，简单有效，简单例子如下：
//省去创建group、queue代码。。。
dispatch_group_async(group, queue, ^{
//Do you work...
});
当你无法直接使用队列变量时，就无法使用dispatch_group_async了，下面以使用AFNetworking时的情况：
// 省去创建group和queue的部分
......
AFHTTPRequestOperationManager *manager = [AFHTTPRequestOperationManager manager];
// Enter group
dispatch_group_enter(group);
[manager GET:@"http://www.baidu.com" parameters:nil success:^(AFHTTPRequestOperation *operation, id responseObject) {
// Deal with result...
// Leave group
dispatch_group_leave(group);
} failure:^(AFHTTPRequestOperation *operation, NSError *error) {
// Deal with error...
// Leave group
dispatch_group_leave(group);
}];
//More request...
使用dispatch_group_enter，dispatch_group_leave就可以方便的将一系列网络请求“打包”起来~
添加结束任务
添加结束任务也可以分为两种情况，如下：
在当前线程阻塞的同步等待：dispatch_group_wait
6、线程批处理
dispatch_apply的作用是在一个队列（串行或并行）上“运行”多次block，其实就是简化了用循环去向队列依次添加block任务。
//创建异步串行队列
dispatch_queue_t queue = dispatch_queue_create("me.tutuge.test.gcd", DISPATCH_QUEUE_SERIAL);
//运行block3次
dispatch_apply(3, queue, ^(size_t i) {
NSLog(@"apply loop: %zu", i);
});
//打印信息
NSLog(@"After apply");
运行的结果是：
2015-04-01 00:55:40.854 GCDTest[47402:1893289] apply loop: 0
2015-04-01 00:55:40.856 GCDTest[47402:1893289] apply loop: 1
2015-04-01 00:55:40.856 GCDTest[47402:1893289] apply loop: 2
2015-04-01 00:55:40.856 GCDTest[47402:1893289] After apply
提交到异步的队列去运行任务，但是“After apply”居然在apply后打印，也就是说，dispatch_apply将外面的线程（main线程）“阻塞”了！Apple城会玩......
7、真正的唯一
dispatch_once这个函数，它可以保证整个应用程序生命周期中某段代码只被执行一次！dispatch_once_t必须是全局或static变量，非全局或非static的dispatch_once_t变量在使用时会导致非常不好排查的bug。
// 静态变量，保证只有一份实例，才能确保只执行一次
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
//单例代码
});
8、延迟提交
dispatch_after是延迟提交，不是延迟运行
先看看官方文档的说明：
Enqueue a block for execution at the specified time.
Enqueue，就是入队，指的就是将一个Block在特定的延时以后，加入到指定的队列中，不是在特定的时间后立即运行。
dispatch_queue_t queue = dispatch_queue_create("me.tutuge.test.gcd", DISPATCH_QUEUE_SERIAL);
NSLog(@"Begin add block...");
dispatch_async(queue, ^{
[NSThread sleepForTimeInterval:10];
NSLog(@"First block done...");
});
// 5 秒以后提交block
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(5 * NSEC_PER_SEC)), queue, ^{
NSLog(@"After...");
});
结果如下：
2015-03-31 20:57:27.122 GCDTest[45633:1812016] Begin add block...
2015-03-31 20:57:37.127 GCDTest[45633:1812041] First block done...
2015-03-31 20:57:37.127 GCDTest[45633:1812041] After...
9、时间
用dispatch_after的时候就会用到dispatch_time_t变量，其原型如下：
dispatch_time_t dispatch_time ( dispatch_time_t when, int64_t delta );
第一个参数一般是DISPATCH_TIME_NOW，表示从现在开始。
那么第二个参数就是真正的延时的具体时间。
这里要特别注意的是，delta参数是“纳秒！”，就是说，延时1秒的话，delta应该是“1000000000”=。=，太长了，所以理所当然系统提供了常量，如下：
#define NSEC_PER_SEC 1000000000ull
#define USEC_PER_SEC 1000000ull
#define NSEC_PER_USEC 1000ull
关键词解释：
NSEC：纳秒。
USEC：微妙。
SEC：秒
PER：每
所以：
NSEC_PER_SEC，每秒有多少纳秒。
USEC_PER_SEC，每秒有多少毫秒。（注意是指在纳秒的基础上）
NSEC_PER_USEC，每毫秒有多少纳秒。
所以，延时1秒可以写成如下几种：
dispatch_time(DISPATCH_TIME_NOW, 1 * NSEC_PER_SEC);
dispatch_time(DISPATCH_TIME_NOW, 1000 * USEC_PER_SEC);
dispatch_time(DISPATCH_TIME_NOW, USEC_PER_SEC * NSEC_PER_USEC);
最后一个“USEC_PER_SEC * NSEC_PER_USEC”，翻译过来就是“每秒的毫秒数乘以每毫秒的纳秒数”，也就是“每秒的纳秒数”。恶心了点......
10、挂起和恢复队列
dispatch_suspend，dispatch_resume提供了“挂起、恢复”队列的功能，简单来说，就是可以暂停、恢复队列上的任务。但是这里的“挂起”，并不能保证可以立即停止队列上正在运行的block，看如下例子：
dispatch_queue_t queue = dispatch_queue_create("me.tutuge.test.gcd", DISPATCH_QUEUE_SERIAL);
//提交第一个block，延时5秒打印。
dispatch_async(queue, ^{
[NSThread sleepForTimeInterval:5];
NSLog(@"After 5 seconds...");
});
//提交第二个block，也是延时5秒打印
dispatch_async(queue, ^{
[NSThread sleepForTimeInterval:5];
NSLog(@"After 5 seconds again...");
});
//延时一秒
NSLog(@"sleep 1 second...");
[NSThread sleepForTimeInterval:1];
//挂起队列
NSLog(@"suspend...");
dispatch_suspend(queue);
//延时10秒
NSLog(@"sleep 10 second...");
[NSThread sleepForTimeInterval:10];
//恢复队列
NSLog(@"resume...");
dispatch_resume(queue);
运行结果如下：
2015-04-01 00:32:09.903 GCDTest[47201:1883834] sleep 1 second...
2015-04-01 00:32:10.910 GCDTest[47201:1883834] suspend...
2015-04-01 00:32:10.910 GCDTest[47201:1883834] sleep 10 second...
2015-04-01 00:32:14.908 GCDTest[47201:1883856] After 5 seconds...
2015-04-01 00:32:20.911 GCDTest[47201:1883834] resume...
2015-04-01 00:32:25.912 GCDTest[47201:1883856] After 5 seconds again...
可知，在dispatch_suspend挂起队列后，第一个block还是在运行，并且正常输出。
结合文档，我们可以得知，dispatch_suspend并不会立即暂停正在运行的block，而是在当前block执行完成后，暂停后续的block执行。
11、其他不常用的函数
dispatch_set_context与dispatch_set_finalizer_f
还有dispatch_set_target_queue
其他不常用的一些函数，在此不再赘述。
12、死锁
// 在main线程使用“同步”方法提交Block，必定会死锁，虽然没人这么干
dispatch_sync(dispatch_get_main_queue(), ^{
NSLog(@"I am block...");
});
- (void)updateUI1 {
dispatch_sync(dispatch_get_main_queue(), ^{
NSLog(@"Update ui 1");
// 嵌套引发死锁！
[self updateUI2];
});
}
- (void)updateUI2 {
dispatch_sync(dispatch_get_main_queue(), ^{
NSLog(@"Update ui 2");
});
}
dispatch_apply导致的死锁！
dispatch_queue_t queue = dispatch_queue_create("me.tutuge.test.gcd", DISPATCH_QUEUE_SERIAL);
dispatch_apply(3, queue, ^(size_t i) {
NSLog(@"apply loop: %zu", i);
// 再来一个dispatch_apply！死锁！
dispatch_apply(3, queue, ^(size_t j) {
NSLog(@"apply loop inside %zu", j);
});
});
这端代码只会输出“apply loop: 1”...然后...就没有然后了
所以要注意多线程嵌套使用，尽可能做到轻量级使用。
另：GCD和NSOperation的区别在于，前者是C函数，后者是基于GCD封装，属于面向对象的多线程抽象。这个和SQLite3和CoreData的区别如出一辙，各有千秋。比如GCD无法如NSOpertion一样精准控制已经发生的Task的生命周期，也没有办法做到并发数的指定等等。但是GCD本身的轻量级就是它最大的优势，依然能完成绝大部分的多线程需求，GCD最主要能理解同步和异步队列区别，全局队列和私有队列，串行队列和并行队列，组队列这四点区别和使用场景基本即可完成绝大部分工作了。
下一篇NSOperation会详细解说与GCD的最大区别。
