关于GCD网上很多介绍, 大部分人都很熟悉, 这里只是本人学习的一个总结, 不到之处,还请指正.
一. 准备
在这之前, 我们需要明白几个比较容易混淆的概念:同步, 异步, 并发, 串行;
- 同步和异步决定了要不要开启新的线程
1.同步: 在当前线程中执行任务, 不具备开启新线程的能力
2.异步: 在新的线程中执行任务, 具备开启新线程的能
- 并发和串行决定了任务的执行方式
1.并发: 多个任务并发(同时)执行
2.串行: 一个任务执行完毕后, 再执行下一个任务(顺序执行)
明白了这几个概念, 再去看GCD相关的一些内容就会比较清晰了.
二. CGD中的队列
1. 串行队列
GCD中获取串行队列有两种途径:
第一种是使用dispatch_queue_create函数创建串行队列:
dispatch_queue_t dispatch_queue_create(const char *label, dispatch_queue_attr_t attr);
参数:
- label: 队列名称, 是一个C的字符串, 可自定义
- attr: 队列类型, 如果传NULL, 就是串行队列; 传DISPATCH_QUEUE_CONCURRENT,可创建并行队列
例如:
//创建串行队列
dispatch_queue_t queue= dispatch_queue_create("串行队列名称", NULL);
// 非ARC需要释放手动创建的队列, 现在一般用不到
dispatch_release(queue);
第二种就是直接使用主队列(跟主线程相关联的队列）
主队列是GCD自带的一种特殊的串行队列, 放在主队列中的任务，都会放到主线程中执行, 使用dispatch_get_main_queue()获得主队列;
例如:
// 获取主队列(串行队列)
dispatch_queue_t queue = dispatch_get_main_queue();
2. 并行队列
并行队列的获取也有两种方式, 第一种上面也有提到, 就是使用** dispatch_queue_create**来创建, 主要第二个参数:
dispatch_queue_t queue = dispatch_queue_create("并发队列", DISPATCH_QUEUE_CONCURRENT);
但是, 我们一般不使用这个方式来获取并行队列, 而是使用系统预定义的全局并发队列;
使用dispatch_get_global_queue函数获得全局的并发队列:
dispatch_queue_t dispatch_get_global_queue(long identifier, unsigned long flags);;
参数:
- identifier: 队列的优先级, 系统预定义了四种, 以供开发者使用
//全局并发队列的优先级
#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 // 后台
- flags: 这个参数是预留给以后使用的, 暂时用不上, 传 0 即可;
例如:
// 获得默认优先级的全局并发队列
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
3. 同步, 异步
同步异步的开启主要是使用下面的函数:
void
dispatch_sync(dispatch_queue_t queue, DISPATCH_NOESCAPE dispatch_block_t block);
同步执行函数, 参数:
- queue: 在哪个队列执行
- block: 执行的任务
void
dispatch_async(dispatch_queue_t queue, dispatch_block_t block);
异步执行函数, 参数:
- queue: 在哪个队列执行
- block: 执行的任务
三. 同步, 异步, 串行, 并发组合测试
下面就来通过实例看一下, 同步, 异步, 串行, 并发直接的一些联系和区别;
测试一: 用同步函数往串行队列中添加任务
不会开启新的线程:
NSLog(@"用同步函数往串行队列中添加任务");
//打印主线程
NSLog(@"主线程----%@",[NSThread mainThread]);
//创建串行队列
dispatch_queue_t queue= dispatch_queue_create("LZQueueName", NULL);
//2.添加任务到队列中执行
dispatch_sync(queue, ^{
NSLog(@"下载图片1----%@",[NSThread currentThread]);
sleep(3);
});
dispatch_sync(queue, ^{
NSLog(@"下载图片2----%@",[NSThread currentThread]);
sleep(2);
});
dispatch_sync(queue, ^{
NSLog(@"下载图片3----%@",[NSThread currentThread]);
});
输出:
2017-01-06 10:11:32.135 LZGCDTest[2938:57629] 用同步函数往串行队列中添加任务
2017-01-06 10:11:32.136 LZGCDTest[2938:57629] 主线程----<NSThread: 0x608000066240>{number = 1, name = main}
2017-01-06 10:11:32.136 LZGCDTest[2938:57629] 下载图片1----<NSThread: 0x608000066240>{number = 1, name = main}
2017-01-06 10:11:35.209 LZGCDTest[2938:57629] 下载图片2----<NSThread: 0x608000066240>{number = 1, name = main}
2017-01-06 10:11:37.280 LZGCDTest[2938:57629] 下载图片3----<NSThread: 0x608000066240>{number = 1, name = main}
可以看到, 是按照任务的添加顺序执行的, 而且是在当前线程(主线程)中执行的, 没有开启新线程(同步函数不具备开启新线程的能力);
测试二: 用同步函数往并发队列中添加任务
不会开启新的线程((同步函数不具备开启新线程的能力))，并发队列失去了并发的功能:
//打印主线程
NSLog(@"主线程----%@",[NSThread mainThread]);
//获取并行队列
dispatch_queue_t queue= dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
// 添加任务到队列中执行
dispatch_sync(queue, ^{
NSLog(@"下载图片1----%@",[NSThread currentThread]);
sleep(3);
});
dispatch_sync(queue, ^{
NSLog(@"下载图片2----%@",[NSThread currentThread]);
sleep(2);
});
dispatch_sync(queue, ^{
NSLog(@"下载图片3----%@",[NSThread currentThread]);
});
输出:
2017-01-06 10:08:37.874 LZGCDTest[2859:55553] 主线程----<NSThread: 0x60800007adc0>{number = 1, name = main}
2017-01-06 10:08:42.892 LZGCDTest[2859:55553] 下载图片1----<NSThread: 0x60800007adc0>{number = 1, name = main}
2017-01-06 10:08:45.966 LZGCDTest[2859:55553] 下载图片2----<NSThread: 0x60800007adc0>{number = 1, name = main}
2017-01-06 10:08:48.035 LZGCDTest[2859:55553] 下载图片3----<NSThread: 0x60800007adc0>{number = 1, name = main}
可以看出, 虽然使用的是并发队列, 但是使用的是同步函数, 由于同步函数没有开启新线程的能力, 所以并发队列就失去了并发性, 按照任务的添加顺序, 顺序执行;
测试三. 用异步函数往串行队列中添加任务
会开启线程，但是只开启一个线程:
//打印主线程
NSLog(@"主线程----%@",[NSThread mainThread]);
//创建串行队列,iOS4.3之后:第二个参数可写 DISPATCH_QUEUE_SERIAL,之前只能NULL
dispatch_queue_t queue= dispatch_queue_create("LZQueueName", NULL);
//2.添加任务到队列中执行
dispatch_async(queue, ^{
NSLog(@"下载图片1----%@",[NSThread currentThread]);
sleep(3);
});
dispatch_async(queue, ^{
NSLog(@"下载图片2----%@",[NSThread currentThread]);
sleep(2);
});
dispatch_async(queue, ^{
NSLog(@"下载图片3----%@",[NSThread currentThread]);
});
输出:
2017-01-06 10:14:28.944 LZGCDTest[3019:60109] 主线程----<NSThread: 0x608000065440>{number = 1, name = main}
2017-01-06 10:14:33.331 LZGCDTest[3019:60150] 下载图片1----<NSThread: 0x60000006f2c0>{number = 3, name = (null)}
2017-01-06 10:14:36.404 LZGCDTest[3019:60150] 下载图片2----<NSThread: 0x60000006f2c0>{number = 3, name = (null)}
2017-01-06 10:14:38.478 LZGCDTest[3019:60150] 下载图片3----<NSThread: 0x60000006f2c0>{number = 3, name = (null)}
可以看到, 任务没有在主线程里执行, 开启了一个新的线程, 虽然是异步, 但是队列是串行队列, 所以任务还是按照添加的顺序, 顺序执行的;
测试四. 用异步函数往并发队列中添加任务
同时开启多个子线程执行任务:
//打印主线程
NSLog(@"主线程----%@",[NSThread mainThread]);
//1.获得全局的并发队列
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
//2.添加任务到队列中，就可以执行任务
//异步函数：具备开启新线程的能力
dispatch_async(queue, ^{
NSLog(@"下载图片1----%@",[NSThread currentThread]);
sleep(3);
});
dispatch_async(queue, ^{
NSLog(@"下载图片2----%@",[NSThread currentThread]);
sleep(2);
});
dispatch_async(queue, ^{
NSLog(@"下载图片2----%@",[NSThread currentThread]);
});
输出:
2017-01-06 10:18:12.210 LZGCDTest[3134:63076] 主线程----<NSThread: 0x60800006e700>{number = 1, name = main}
2017-01-06 10:18:12.211 LZGCDTest[3134:63122] 下载图片1----<NSThread: 0x60000007c040>{number = 3, name = (null)}
2017-01-06 10:18:12.211 LZGCDTest[3134:63121] 下载图片2----<NSThread: 0x6080002671c0>{number = 4, name = (null)}
2017-01-06 10:18:12.211 LZGCDTest[3134:63124] 下载图片2----<NSThread: 0x60800026fe80>{number = 5, name = (null)}
可以看出, 这里开启了三个子线程来执行任务.
以上四个测试, 能够看出同步, 异步, 串行, 并行之间的关系, 只有异步函数和并行队列组合才能真正实现并发的效果.
测试五. 控制最大并发数
在进行并发操作的时候, 如果任务过多, 开启很多线程, 会导致APP卡死. 所以, 我们要控制最大并发数, 这就用到了信号量, 与之相关的三个函数为:
// value : 必须是大于等于0的数, 否则会返回NULL
dispatch_semaphore_t
dispatch_semaphore_create(long value);
long
dispatch_semaphore_wait(dispatch_semaphore_t dsema, dispatch_time_t timeout);
long
dispatch_semaphore_signal(dispatch_semaphore_t dsema);
这里有一篇文章是介绍信号量的, 可参考:关于dispatch_semaphore的使用
一个应用示例:
dispatch_group_t group = dispatch_group_create();
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
// 设置最大任务数
dispatch_semaphore_t semaphore = dispatch_semaphore_create(10);
for (int i = 0; i < 100; i++) {
dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
dispatch_group_async(group, queue, ^{
// 执行任务
NSLog(@"%d", i);
// 模拟任务时间, 休眠2s
sleep(2);
dispatch_semaphore_signal(semaphore);
});
}
dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
这样就会, 每十个一组的进行输出...
四. 一些应用
下面给出一些, GCD在编程中的常用示例:
1. 只执行一次
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
});
这个同常用来创建单例, 能够保证block内的代码只执行一次.
2. 延迟执行
dispatch_time_t time = dispatch_time ( DISPATCH_TIME_NOW , 3ull * NSEC_PER_SEC ) ;
dispatch_after ( time , dispatch_get_main_queue (),^{
NSLog ( @"waited at least three seconds." );
});
这里是延迟3s来执行block内的任务;
3. 重复执行
dispatch_apply(5, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^(size_t index) {
NSLog(@"重复执行5次");
});
这个方法可以重复执行某个任务, 这里执行5次输出;
4. 指定执行
如果, 你想某个任务在其他任务执行之后再执行, 或者必须某个任务执行完,才能执行下面的任务, 可以使用这个函数dispatch_barrier_async :
dispatch_queue_t queue = dispatch_queue_create("LZQueueName", DISPATCH_QUEUE_CONCURRENT);
dispatch_async(queue, ^{
[NSThread sleepForTimeInterval:2];
NSLog(@"dispatch_async1");
});
dispatch_async(queue, ^{
[NSThread sleepForTimeInterval:4];
NSLog(@"dispatch_async2");
});
dispatch_barrier_async(queue, ^{
NSLog(@"dispatch_barrier_async");
[NSThread sleepForTimeInterval:4];
});
dispatch_async(queue, ^{
[NSThread sleepForTimeInterval:1];
NSLog(@"dispatch_async3");
});
这里是使用的并发队列异步执行, 按说应该是互不影响的, 但是有了** dispatch_barrier_async** ,他的作用就是在他前面的任务执行结束后它才执行，而且它后面的任务等它执行完成之后才会执行.
输出:
2017-01-06 10:33:03.063 LZGCDTest[3454:71023] dispatch_async1
2017-01-06 10:33:05.004 LZGCDTest[3454:71026] dispatch_async2
2017-01-06 10:33:05.004 LZGCDTest[3454:71026] dispatch_barrier_async
2017-01-06 10:33:10.151 LZGCDTest[3454:71026] dispatch_async3
5. 汇总dispatch_group_async
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:3];
NSLog(@"group1");
});
dispatch_group_async(group, queue, ^{
[NSThread sleepForTimeInterval:2];
NSLog(@"group2");
});
dispatch_group_async(group, queue, ^{
[NSThread sleepForTimeInterval:3];
NSLog(@"group3");
});
dispatch_group_notify(group, dispatch_get_main_queue(), ^{
NSLog(@"updateUi");
});
输出:
2017-01-06 10:41:02.099 LZGCDTest[3668:76419] group2
2017-01-06 10:41:03.098 LZGCDTest[3668:76416] group3
2017-01-06 10:41:03.098 LZGCDTest[3668:76417] group1
2017-01-06 10:41:03.099 LZGCDTest[3668:76375] updateUi
6. 延长后台运行时间
当用户使用Home键使APP后台运行, 一般只有最多5s的时间, 就会被系统杀死, 如果在这些时间里你不能完成一些操作, 例如清理缓存, 保存数据, 就有可能造成数据丢失, 这时可以使用这个方法, 来使程序的后台运行时间延长至10分钟左右:
// AppDelegate.h文件
@property (assign, nonatomic) UIBackgroundTaskIdentifier backgroundUpdateTask;
// AppDelegate.m文件
- (void)applicationDidEnterBackground:(UIApplication *)application
{
[self beingBackgroundUpdateTask];
// 在这里加上你需要长久运行的代码
[self endBackgroundUpdateTask];
}
- (void)beingBackgroundUpdateTask
{
self.backgroundUpdateTask = [[UIApplication sharedApplication] beginBackgroundTaskWithExpirationHandler:^{
[self endBackgroundUpdateTask];
}];
}
- (void)endBackgroundUpdateTask
{
[[UIApplication sharedApplication] endBackgroundTask: self.backgroundUpdateTask];
self.backgroundUpdateTask = UIBackgroundTaskInvalid;
}
网友评论