昨天通过多线程实现方案之 -- NSThread说了关于 NSThread 多线程的一些知识点和用法, 其实之前我也写过一篇关于 GCD 的分享-iOS - GCD 编程, 使用的 GCD 是基于封装过的, 今天是深入学习总结 GCD 相关知识以及 GCD 在实际开发中的使用
什么是 GCD
- 全称是 Grand Central Dispatch
- 纯 C语言, 提供了非常强大的函数
GCD 的优势
- GCD 是苹果公司为多核的并发运算提出的解决方案
- GCD 会自动利用更多的 CPU 内核(比如双核, 四核)
- GCD 会自动管理线程的生命周期, (创建线程, 调度任务, 销毁线程)
- 程序员只需要告诉 GCD 需要执行什么任务, 不需要编写任何线程管理代码
任务和队列
GCD 中有两个核心概念
- 任务: 执行什么操作
- 队列: 用来仿什么任务
GCD 使用的两个步骤
-
定制任务
- 确定想要做的事情
-
讲任务添加到队列中
- GCD 会自动将队列中的任务取出, 放到对应的线程中执行
- 任务的取出遵循队列的 FIFO 原则: 先进先出, 后进后出
执行任务
GCD 中有两个用来执行任务的常用函数
- 用同步的方式执行任务
dispatch_sync(dispatch_queue_t queue, ^{
// block 内容
});
queue: 队列
bolck: 任务
- 用异步方式来执行
dispatch_async(dispatch_queue_t queue, ^{
// block 内容
});
同步和异步的区别
- 同步: 只能在当前线程中执行任务, 不具备开新启线程的能力
- 异步: 可以在新的线程中执行任务, 具备开启新线程的能力
队列的类型
并发队列(Concurrent Dispatch Queue)
概念:
- 可以让多个任务并发(同时)执行(自动开启多个线程同时执行任务)
- 并发功能只有在异步(dispatch_async)函数下才有效
创建方法:
dispatch_queue_t queue = dispatch_queue_create("abc", DISPATCH_QUEUE_CONCURRENT);
因为 GCD 默认已经提供了全局并发队列, 供整个应用使用, 也可以直接获取
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
// 第一个参数是队列优先级, 第二个参数一般都是0, 没什么用
串行队列(Serial Dispatch Queue)
概念:
- 让任务一个接着一个的执行 (一个任务执行完毕再执行下一个任务)
创建方式:
// 第二个队列类型可以传 NULL 或者 DISPATCH_QUEUE_SERIAL 效果是一样的
dispatch_queue_t queue = dispatch_queue_create("abc", DISPATCH_QUEUE_SERIAL);
还可以使用主队列, 也就是跟主线程想关联的队列
- 主队列是 GCD 自带的一种特殊串行队列
- 放在主队列中的任务, 多会放到主线程中执行
- 使用
dispatch_get_main_queue()获得主队列
容易混淆的术语
在 GCD 使用的时候有4个概念比较容易混淆: 同步 - 异步 - 并发 - 串行
-
同步和异步主要影响: 能不能开启新线程
- 同步: 只是在当前线程中执行任务, 不具备开启新线程的能力
- 异步: 可以在新的线程中执行任务, 具备开启新线程的能力
-
并发和串行主要影响: 任务的执行方式
- 并发: 允许多个任务并发执行
- 串行: 一个任务执行完毕, 才去执行下一个任务
GCD 的基本使用
同步函数和并发队列
直接上代码
- (void)syncConcurrent {
// 创建队列
/*
第一个参数: C语言的字符串,标签
第二个参数: 队列的类型
*/
dispatch_queue_t queue = dispatch_queue_create("download", DISPATCH_QUEUE_CONCURRENT);
// 定制任务(多任务)
dispatch_sync(queue, ^{
NSLog(@"download1- %@", [NSThread currentThread]);
});
dispatch_sync(queue, ^{
NSLog(@"download2- %@", [NSThread currentThread]);
});
dispatch_sync(queue, ^{
NSLog(@"download3- %@", [NSThread currentThread]);
});
}
打印结果:
2016-07-28 11:14:52.766 GCD[18620:1367714] download1- <NSThread: 0x7f9ee8e014b0>{number = 1, name = main}
2016-07-28 11:14:52.767 GCD[18620:1367714] download2- <NSThread: 0x7f9ee8e014b0>{number = 1, name = main}
2016-07-28 11:14:52.770 GCD[18620:1367714] download3- <NSThread: 0x7f9ee8e014b0>{number = 1, name = main}
同步函数是不会开启子线程的, 所有任务都是在主线程中串行执行的.
同步函数和串行队列
代码:
- (void)syncSerial {
dispatch_queue_t queue = dispatch_queue_create("download", DISPATCH_QUEUE_SERIAL);
dispatch_sync(queue, ^{
NSLog(@"download1- %@", [NSThread currentThread]);
});
dispatch_sync(queue, ^{
NSLog(@"download2- %@", [NSThread currentThread]);
});
dispatch_sync(queue, ^{
NSLog(@"download3- %@", [NSThread currentThread]);
});
}
打印结果:
2016-07-28 11:18:56.510 GCD[18829:1370325] download1- <NSThread: 0x7fe08bf00af0>{number = 1, name = main}
2016-07-28 11:18:56.511 GCD[18829:1370325] download2- <NSThread: 0x7fe08bf00af0>{number = 1, name = main}
2016-07-28 11:18:56.513 GCD[18829:1370325] download3- <NSThread: 0x7fe08bf00af0>{number = 1, name = main}
同样, 此时也是不会创建子线程的, 所有任务是在主线程中也是串行执行, 和同步函数和并发队列时候是一样的效果.
同步函数和主队列
这个就有点特殊了, 为了看效果, 在方法里面加上开始和结束的代码:
- (void)syncMain {
NSLog(@"---start---");
dispatch_queue_t queue = dispatch_get_main_queue();
dispatch_sync(queue, ^{
NSLog(@"download1- %@", [NSThread currentThread]);
});
dispatch_sync(queue, ^{
NSLog(@"download2- %@", [NSThread currentThread]);
});
dispatch_sync(queue, ^{
NSLog(@"download3- %@", [NSThread currentThread]);
});
NSLog(@"---end---");
}
打印结果:
2016-07-28 12:02:20.473 GCD[21183:1395248] ---start---
并没有打印结束语句, 说明任务也没有执行,这是怎么回事呢?
- 这是因为主列发中的任务都是在主线程中执行, 当主队列发现当前主线程有任务在执行, 那主队列会暂定调用对队列中的任务,直到主线程空闲为止.
- 简单点说, 就是主线程发现有任务, 就要让主线程去执行任务, 但此时的主线程却在等待这任务执行完毕, 不是空闲状态, 所以主线程无法执行任务, 形成死锁. 而同步函数又要求任务要立刻马上按顺序执行, 所以第一个任务执行不了, 后面的当然也执行不了 , 就卡在了那里.
那有没有办法让同步函数和主队列中的任务执行呢? 当然可以, 只是需要把这个方法放到子线程中去, 看代码:
[NSThread detachNewThreadSelector:@selector(syncMain) toTarget:self withObject:nil];
这个时候再看执行结果:
2016-07-28 12:17:01.477 GCD[21971:1403347] ---start---
2016-07-28 12:17:01.481 GCD[21971:1403123] download1- <NSThread: 0x7fca2bc02470>{number = 1, name = main}
2016-07-28 12:17:01.500 GCD[21971:1403123] download2- <NSThread: 0x7fca2bc02470>{number = 1, name = main}
2016-07-28 12:17:01.503 GCD[21971:1403123] download3- <NSThread: 0x7fca2bc02470>{number = 1, name = main}
2016-07-28 12:17:01.504 GCD[21971:1403347] ---end---
发现已经全部执行完毕了, 而且是在主线程中执行的. 这是因为我们是开启的子线程来调用方法, 此时的主线程是空闲的, 然后方法中的任务需要在主线程中执行, 就没有问题了.
异步函数和并发队列
定制三个任务, 看执行效果
- (void)asyncConcurrent {
dispatch_queue_t queue = dispatch_queue_create("download", DISPATCH_QUEUE_CONCURRENT);
// 也可以获取全局并发队列,执行效果是一样的
// dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_async(queue, ^{
NSLog(@"download1- %@", [NSThread currentThread]);
});
dispatch_async(queue, ^{
NSLog(@"download2- %@", [NSThread currentThread]);
});
dispatch_async(queue, ^{
NSLog(@"download3- %@", [NSThread currentThread]);
});
}
打印结果:
2016-07-28 10:58:05.941 GCD[17694:1357547] download1- <NSThread: 0x7f9c5b6155e0>{number = 2, name = (null)}
2016-07-28 10:58:05.943 GCD[17694:1357551] download3- <NSThread: 0x7f9c5b551df0>{number = 4, name = (null)}
2016-07-28 10:58:05.942 GCD[17694:1357550] download2- <NSThread: 0x7f9c5b548b30>{number = 3, name = (null)}
可以看出队列开启了三条子线程区分别执行三个任务, 队列中的任务是并发执行的. 但是在这里有个注意点:
并不是说有多少任务GCD 就会开启多少条线程, 具体开启几条线程是不确定的, 这个是由系统决定的.
异步函数和串行队列
同样是三个任务,看执行效果
- (void)asyncSerial {
dispatch_queue_t queue = dispatch_queue_create("download", DISPATCH_QUEUE_SERIAL);
dispatch_async(queue, ^{
NSLog(@"download1- %@", [NSThread currentThread]);
});
dispatch_async(queue, ^{
NSLog(@"download2- %@", [NSThread currentThread]);
});
dispatch_async(queue, ^{
NSLog(@"download3- %@", [NSThread currentThread]);
});
}
打印结果
2016-07-28 11:08:08.933 GCD[18241:1363508] download1- <NSThread: 0x7f80c0f11330>{number = 2, name = (null)}
2016-07-28 11:08:08.934 GCD[18241:1363508] download2- <NSThread: 0x7f80c0f11330>{number = 2, name = (null)}
2016-07-28 11:08:08.934 GCD[18241:1363508] download3- <NSThread: 0x7f80c0f11330>{number = 2, name = (null)}
队列只开启了一条子线程, 去一个接着一个任务去执行.
这种方式对任务的执行效率没有任何提高.
异步函数和主队列
代码:
- (void)asyncMain {
dispatch_queue_t queue = dispatch_get_main_queue();
dispatch_async(queue, ^{
NSLog(@"download1- %@", [NSThread currentThread]);
});
dispatch_async(queue, ^{
NSLog(@"download2- %@", [NSThread currentThread]);
});
dispatch_async(queue, ^{
NSLog(@"download3- %@", [NSThread currentThread]);
});
}
打印结果:
2016-07-28 11:55:12.710 GCD[20775:1389553] download1- <NSThread: 0x7fc4ea7033b0>{number = 1, name = main}
2016-07-28 11:55:12.712 GCD[20775:1389553] download2- <NSThread: 0x7fc4ea7033b0>{number = 1, name = main}
2016-07-28 11:55:12.712 GCD[20775:1389553] download3- <NSThread: 0x7fc4ea7033b0>{number = 1, name = main}
主队列所有的任务确实是在主线程执行的, 虽然是异步函数, 但也不会开启线程.
各种队列执行效果总结
直接在 Excel 里做了个表
总结: GCD 里, 非主队列情况下只有异步函数才会开启新线程, 此时如果是并发队列, 会开启多条线程,如果是串行队列, 只会开启一条线程, 其他情况下(包括主队列) 都不会开启新线程,并且是串行执行任务.
GCD 线程间通信
GCD 线程间通信相对来说是比较简单的, 直接使用嵌套就可以了.
// 开启子线程下载图片
// dispatch_sync 和 dispatch_async 两者效果一样,因为是在子线程下载的
dispatch_async(dispatch_get_global_queue(0, 0), ^{
// 网络图片 url
NSURL *url = [NSURL URLWithString:@"http://pic12.nipic.com/20110114/6621051_221433460330_2.jpg"];
// 下载二进制数据到本地
NSData *data = [NSData dataWithContentsOfURL:url];
// 获取图片
UIImage *image = [[UIImage alloc] initWithData:data];
// 回到主线程刷新 UI 图片
dispatch_async(dispatch_get_main_queue(), ^{
self.imageView.image = image;
});
});
这样就能实现在子线程下载图片,回到主线程刷新 UI 并设置图片
GCD 常用函数
delay 延迟操作
先看前两种方法
NSLog(@"-----start-----");
// 延迟方法 第一种
[self performSelector:@selector(task) withObject:nil afterDelay:3.0];
// 第二种
//[NSTimer scheduledTimerWithTimeInterval:3.0 target:self selector:@selector(task) userInfo:nil repeats:YES];
方法实现:
- (void)task {
NSLog(@"task-%@", [NSThread currentThread]);
}
打印结果是一样的
2016-07-28 13:27:16.779 GCD 常用函数[25917:1453136] -----start-----
2016-07-28 13:27:19.782 GCD 常用函数[25917:1453136] task-<NSThread: 0x7fa1ca604cf0>{number = 1, name = main}
只不过 NSTimer 会循环打印
用 GCD 会更简单一些
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(3.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
NSLog(@"GCD-%@", [NSThread currentThread]);
});
不需要额外写其他方法, 在 block 里直接声明要执行的任务就可以了.
2016-07-28 13:30:20.043 GCD 常用函数[26131:1456661] -----start-----
2016-07-28 13:30:23.342 GCD 常用函数[26131:1456661] GCD-<NSThread: 0x7fe4687013f0>{number = 1, name = main}
也能达到延迟操作的作用, 此时是默认在主线程中执行的 . GCD 可以修改任务任务执行所在的线程.
dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(3.0 * NSEC_PER_SEC)), queue, ^{
NSLog(@"GCD-%@", [NSThread currentThread]);
});
此时的执行效果
2016-07-28 13:33:57.186 GCD 常用函数[26332:1459149] -----start-----
2016-07-28 13:34:00.188 GCD 常用函数[26332:1459321] GCD-<NSThread: 0x7f90c37146b0>{number = 2, name = (null)}
可以看到任务是在子线程中执行的.
once 一次性执行
直接上代码
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
NSLog(@"once - %@", [NSThread currentThread]);
});
打印结果:
2016-07-28 13:37:36.106 GCD 常用函数[26532:1461714] once - <NSThread: 0x7fead2e01670>{number = 1, name = main}
之后就不会再运行了, 它是在整个运行程序中只会执行一次, GCD 的一次性执行代码一般都是用在单例设计模式中.保证全局只有一个对象实例.
GCD 栅栏函数
在异步函数中控制任务执行的顺序, 只有当栅栏函数执行完毕之后才会执行后面的任务.
- 注意:栅栏函数不能使用全局并发队列
依然不善表达,直接上代码, 为了能看出效果, 让每个任务都执行10次:
// 创建并发队列
dispatch_queue_t queue = dispatch_queue_create("aaa", DISPATCH_QUEUE_CONCURRENT);
// 异步函数
dispatch_async(queue, ^{
for (int i = 0; i < 10; ++i) {
NSLog(@"download1 - %@", [NSThread currentThread]);
}
});
dispatch_async(queue, ^{
for (int i = 0; i < 10; ++i) {
NSLog(@"download2 - %@", [NSThread currentThread]);
}
});
// 栅栏函数
dispatch_barrier_async(queue, ^{
NSLog(@"++++++++++++++++++++++++++++++++++++++++");
});
dispatch_async(queue, ^{
for (int i = 0; i < 10; ++i) {
NSLog(@"download3 - %@", [NSThread currentThread]);
}
});
执行结果:
只有在栅栏函数前面的任务全部执行完毕后, 才会执行后面的任务.
GCD 的 apply (快速迭代)
迭代: 也就是 遍历
之前我们用的最多的就是 for 循环区遍历10000次任务, 接下来我们就对比一下两者有什么区别, 为了看出效果, 都加上耗时计算
首先是 for 循环
NSDate* tmpStartData = [NSDate date];
for (int i = 0; i < 10000; ++i) {
NSLog(@"for- %d -- %@", i, [NSThread currentThread]);
}
double deltaTime = [[NSDate date] timeIntervalSinceDate:tmpStartData];
NSLog(@"for 耗时 = %f", deltaTime);
运行结果:
for 循环用时约 10.5秒, 而且全部是在主线程中执行的
接着用 GCD 的快速迭代
NSDate* tmpStartData = [NSDate date];
/*
第一个参数: 迭代次数
第二个参数: 线程队列(并发队列)
第三个参数: index 索引
*/
dispatch_apply(10000, dispatch_get_global_queue(0, 0), ^(size_t index) {
NSLog(@"GCD- %zd -- %@", index, [NSThread currentThread]);
});
double deltaTime = [[NSDate date] timeIntervalSinceDate:tmpStartData];
NSLog(@"GCD 耗时 = %f", deltaTime);
运行结果
从上面两张图可以看出, GCD 快速迭代的是开启了子线程去执行的,而且主线程也参与了, 由于不是一个线程, 所以迭代也不是按顺序的. 最后,用时5.08秒, 明显快于 for 循环遍历.
GCD 队列组
队列组的作用: 当执行队列组通知模块时能保证放进队列组里的任务全部执行完毕了(之前那篇iOS - GCD 编程里也有类似介绍,不过那个是对 GCD 封装过的方法)
```
// 创建队列
dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
// 创建队列组
dispatch_group_t group = dispatch_group_create();
//队列组异步函数执行任务
dispatch_group_async(group, queue, ^{
NSLog(@"任务1 -- %@", [NSThread currentThread]);
});
dispatch_group_async(group, queue, ^{
NSLog(@"任务2 -- %@", [NSThread currentThread]);
});
dispatch_group_async(group, queue, ^{
NSLog(@"任务3 -- %@", [NSThread currentThread]);
});
// 队列组拦截通知模块(内部本身是异步执行的,不会阻塞线程)
dispatch_group_notify(group, queue, ^{
NSLog(@"------队列租任务执行完毕-------");
});
```
执行效果:
- 关于 GCD 的相关知识点基本总结完毕, 下篇文章接着总结 NSOperation 的相关知识点
相关文章:
iOS 多线程知识点总结之: 进程和线程
iOS 多线程实现方案之 -- NSThread
iOS - GCD 编程
