GCD: GCD的核心概念就是把任务添加到队列中,指定任务执行的方法.
1 :任务,使用Block封装好的代码段就是一个任务.
2 :队列,分串行队列,并发队列2种:
串行: 1个一个的调任务,主线程也是串行队列
并发: 可以同时调度多个任务,
3 :执行: 执行又分同步执行和异步执行:
同步: 同步执行每个任务不完成的时候不会执行下一个命令
异步: 当前任务不完成一样可以执行下一个命令.
队列类型:
// 队列类型
dispatch_queue_t
创建一个队列:
// dispatch_queue_t 返回值队列
// const char *label 队列名字
// dispatch_queue_attr_t attr 队列类型
dispatch_queue_t
dispatch_queue_create(const char *label, dispatch_queue_attr_t attr);
dispatch_queue_attr_t 队列类型:
DISPATCH_QUEUE_SERIAL : 串行队列 ,等待执行中的处理结果.
DISPATCH_QUEUE_CONCURRENT : 并发队列,不等待执行中的处理结果.
实例:创造一个队列
dispatch_queue_t que = dispatch_queue_create("label", DISPATCH_QUEUE_SERIAL);
获得一个全局的并发队列:
// dispatch_queue_t 返回值一个队列
// long identifier 队列的优先级
// unsigned long flags 传 0
dispatch_queue_t
dispatch_get_global_queue(long identifier, unsigned long flags);
队列的优先级:
ios7
#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 后台
ios8
QOS_CLASS_USER_INTERACTIVE 用户希望线程快点执行完毕,不要使用耗时操作
QOS_CLASS_USER_INITIATED 用户需要的,不要使用耗时操作QOS_CLASS_DEFAULT 默认
QOS_CLASS_UTILITY 耗时操作
QOS_CLASS_BACKGROUND 后台
QOS_CLASS_UNSPECIFIED 0 未指定优先级
实例:
dispatch_queue_t queget = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0);
获取一个当前的主队列:
// dispatch_queue_t 队列 这里返回的是主队列
dispatch_queue_t
dispatch_get_main_queue(void)
实例:
dispatch_queue_t mainque = dispatch_get_main_queue();
线程之间的执行顺序:
同步执行:
void
dispatch_sync(dispatch_queue_t queue, dispatch_block_t block);
同步串行实例: 这里的代码将 封装的代码一个一个放入到que的队列中去执行,因为是串行的所以会一个一个执行,因为是同步执行,所以在一个执行完以前不会执行下一个.并且不会开新线程.
串行同步.png
dispatch_queue_t que = dispatch_queue_create("label", DISPATCH_QUEUE_SERIAL);
for (int i = 0 ; i<10; i++) {
dispatch_sync(que, ^{
NSLog(@"%@",[NSThread currentThread]);
});
}
同步并发实例:这里的代码将 封装的代码一个一个放入到que的队列中去执行,虽然是并发队列了,但是因为是同步执行的原因,在一个代码执行完成之前,不能执行另外一个任务,所以仍然一个一个执行,并且不会开启新的线程.
并发同步.png
dispatch_queue_t que = dispatch_queue_create("label", DISPATCH_QUEUE_CONCURRENT);
for (int i = 0 ; i<10; i++) {
dispatch_sync(que, ^{
NSLog(@"%@",[NSThread currentThread]);
});
}
异步执行:
// dispatch_queue_t queue 队列
// dispatch_block_t block 封装的代码段
void
dispatch_async(dispatch_queue_t queue, dispatch_block_t block);
异步执行串行队列实例: 封装的代码一个一个放入到que的队列中去执行,因为是异步执行所以会再另开一条线程去执行,而又因为是串行队列,在一个任务执行完成前不会执行下一个所以只开1条线程,并且主线程继续执行.
异步执行串行队列.png
dispatch_queue_t que = dispatch_queue_create("label", DISPATCH_QUEUE_SERIAL);
for (int i = 0 ; i<10; i++) {
dispatch_async(que, ^{
NSLog(@"%@",[NSThread currentThread]);
});
}
异步执行并发队列实例: 封装的代码一个一个放入到que的队列中去执行,因为是异步执行所以会再另开一条线程去执行,而又因为是并发队列,在一个任务执行完成前就会开一条新线程继续执行直到一个执行完,会开几条 新线程.
异步执行并发队列.png
dispatch_queue_t que = dispatch_queue_create("label", DISPATCH_QUEUE_CONCURRENT);
for (int i = 0 ; i<10; i++) {
dispatch_async(que, ^{
NSLog(@"%@",[NSThread currentThread]);
});
}
主线程的同步死锁实例: 程序会卡主.主队列在等待 dispatch_sync调度完任务才会向下执行,而dispatch_sync也在等待主队列执行完才会执行
dispatch_queue_t mainque = dispatch_get_main_queue();
for (int i = 0 ; i<10; i++) {
dispatch_sync(mainque, ^{
NSLog(@"%@",[NSThread currentThread]);
});
}
NSLog(@"结束");
主线程的异步实例:先执行完主线程,在执行dispatch_async
dispatch_queue_t mainque = dispatch_get_main_queue();
for (int i = 0 ; i<10; i++) {
dispatch_async(mainque, ^{
NSLog(@"%@",[NSThread currentThread]);
});
}
解决同步死锁的方法:用异步的方式先开启子线程,在回到主线程同步执行
dispatch_queue_t que = dispatch_queue_create("label", DISPATCH_QUEUE_CONCURRENT);
dispatch_queue_t mainque = dispatch_get_main_queue();
dispatch_async(que, ^{
NSLog(@"%@",[NSThread currentThread]);
for (int i = 0 ; i<10; i++) {
dispatch_sync(mainque, ^{
NSLog(@"%@",[NSThread currentThread]);
});
}
});
延迟执行:
将一段代码延迟执行:
// dispatch_time_t when 要延迟多少时间
// dispatch_queue_t queue 在哪个线程执行
// dispatch_block_t block执行的代码段.
void
dispatch_after(dispatch_time_t when,
dispatch_queue_t queue,
dispatch_block_t block);
得出dispatch_time_t when延迟时间
// 一个固定计算的公式 返回值是秒数
dispatch_time_t
dispatch_time(dispatch_time_t when, int64_t delta);
实例:
// <#delayInSeconds#> 这里写秒数 如3.0.
dispatch_time(DISPATCH_TIME_NOW, (int64_t)(<#delayInSeconds#> * NSEC_PER_SEC)
完整实例:
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(3.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
NSLog(@"3秒到了");
});
整个程序只执行一次:
只调用一次:
// dispatch_once_t *predicate 一个标记 是一个long类型传入的是这个类型的地址&
// dispatch_block_t block 这个代码段在程序中,只调用一次.
_dispatch_once(dispatch_once_t *predicate, dispatch_block_t block)
实例:
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
NSLog(@"只调用1次");
});
组:
调度组:
// 调度组的类型
DISPATCH_DECL(dispatch_group);
dispatch_group_t group;
生成一个调度组
// dispatch_group_t 返回一个调度组.
dispatch_group_t
dispatch_group_create(void);
实例:
dispatch_group_t group = dispatch_group_create();
将一个任务异步的方式添加到调度组中
// dispatch_group_t group 哪个组
// dispatch_queue_t queue 哪个队列
// dispatch_block_t block 任务执行的代码段
void
dispatch_group_async(dispatch_group_t group,
dispatch_queue_t queue,
dispatch_block_t block);
实例:
dispatch_queue_t que = dispatch_queue_create("label", DISPATCH_QUEUE_CONCURRENT);
dispatch_group_t group = dispatch_group_create();
dispatch_group_async(group, que, ^{
NSLog(@"%@ 队列0",[NSThread currentThread]);
});
当调度组线程与任务执行完后:
当一个调度组执行完后执行的代码,这种等待是异步的,如果在这段代码下写了其他代码会先执行其他代码 等调度组的所有任务线程都执行完毕后才会执行dispatch_group_notify中的代码.
// dispatch_group_t group 哪个调度组
// dispatch_queue_t queue 哪个队列
// dispatch_block_t block 执行的代码段
void
dispatch_group_notify(dispatch_group_t group,
dispatch_queue_t queue,
dispatch_block_t block);
实例:
dispatch_group_notify(group, mainque, ^{
NSLog(@"执行完了");
});
同步等待调度组回调:
// dispatch_group_t group 哪个组
// dispatch_time_t timeout 等待时间
long
dispatch_group_wait(dispatch_group_t group, dispatch_time_t timeout);
实例
dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
标记: 进入组与离开组:
// 进入组的标志
void
dispatch_group_enter(dispatch_group_t group);
// 离开组的标志
void
dispatch_group_leave(dispatch_group_t group);
一个小实例
dispatch_group_t group = dispatch_group_create();
dispatch_group_enter(group);
void(^test)() = ^{
NSLog(@"测试");
dispatch_group_leave(group);
};
dispatch_async(dispatch_get_global_queue(0, 0), test);
dispatch_group_notify(group, dispatch_get_global_queue(0, 0), ^{
NSLog(@"执行完成");
});
NSLog(@"先执行否");
