详细谈谈GCD
1. GCD是iOS4时推出的,目的是用来取代NSThread(ios2.0推出的),是C语言框架,它能够自动利用更多CPU的核数,并且会自动管理线程的生命周期.
- GCD有两个核心概念:
任务,队列 - 任务: 记为在block中执行的代码
- 队列: 用来存放任务滴
- 注意事项:
- 队列!=线程.队列中存放的任务最后都要由线程来执行!
- 队列的原则: 先进先出,后进后出
2.队列分为四种:
- 串行队列: 任务一个接一个的执行
- 并发队列: 队列中的任务并发执行
- 主队列: 跟主线程相关的队列,主队列里面的内容都会在主线程中执行(一般在主线程中刷新UI).
- 全局队列: 由系统提供的 一个特殊的并发队列,全局队列是所有应用程序共享的。.
3.并发队列与全局队列的区别
- 并发队列有名称,可以跟踪错误(需要手动创建).全局队列没有名称(由系统提供的)
- 在ARC中两个队列不需要考虑释放内存,但在MRC中并发队列是手动创建出来滴需要release操作,而全局队列只在一个不需要release
- 一般在开发过程中,使用全局队列.
1.执行任务的两个函数
-
同步执行任务dispatch_sync(<#dispatch_queue_t _Nonnull queue#>, <#^(void)block#>) -
异步执行任务dispatch_async(<#dispatch_queue_t _Nonnull queue#>, <#^(void)block#>)
2.同步和异步的区别
-
同步: 只能在当前线程中执行任务,不具备开启新线程的能力. -
异步: 可以在新的线程中执行任务,具备开启新线程的能力.
3.各个队列的执行效果
- 串行队列同步执行,既在当前线程顺序执行
dispatch_queue_t serialQ = dispatch_queue_create("com.lekan.serialqueue", DISPATCH_QUEUE_SERIAL);
dispatch_sync(serialQ, ^{
NSLog(@"串行队列同步执行 1 --- %@",[NSThread currentThread]);
});
dispatch_sync(serialQ, ^{
NSLog(@"串行队列同步执行 2 --- %@",[NSThread currentThread]);
});
dispatch_sync(serialQ, ^{
NSLog(@"串行队列同步执行 3 --- %@",[NSThread currentThread]);
});
/*
2018-11-12 10:43:48.794110+0800 10-掌握-NSOperation操作依赖和监听[2038:305788] 串行队列同步执行 1 --- {number = 1, name = main}
2018-11-12 10:43:48.795386+0800 10-掌握-NSOperation操作依赖和监听[2038:305788] 串行队列同步执行 2 --- {number = 1, name = main}
2018-11-12 10:43:48.795577+0800 10-掌握-NSOperation操作依赖和监听[2038:305788] 串行队列同步执行 3 --- {number = 1, name = main}
*/
串行队列异步执行,开辟一条新的线程,在该线程中顺序执行
dispatch_queue_t serialQ = dispatch_queue_create("com.lekan.serialqueue", DISPATCH_QUEUE_SERIAL);
for (NSInteger i=0; i<4; i++) {
dispatch_async(serialQ, ^{
NSLog(@"串行队列异步执行 %zd --- %@",i,[NSThread currentThread]);
});
}
/*
2018-11-12 10:54:26.777223+0800 10-掌握-NSOperation操作依赖和监听[2148:333376] 串行队列异步执行 0 --- {number = 3, name = (null)}
2018-11-12 10:54:26.777487+0800 10-掌握-NSOperation操作依赖和监听[2148:333376] 串行队列异步执行 1 --- {number = 3, name = (null)}
2018-11-12 10:54:26.777669+0800 10-掌握-NSOperation操作依赖和监听[2148:333376] 串行队列异步执行 2 --- {number = 3, name = (null)}
2018-11-12 10:54:26.777824+0800 10-掌握-NSOperation操作依赖和监听[2148:333376] 串行队列异步执行 3 --- {number = 3, name = (null)}
*/
并行队列同步执行,不开辟线程,在当前线程中顺序执行
全局队列：本质是一个并发队列，由系统提供，方便编程，可以不用创建就直接使用。
for (NSInteger i=1; i<5; i++) {
dispatch_sync(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
NSLog(@"并行队列同步步执行 %zd --- %@",i,[NSThread currentThread]);
});
}
/*
2018-11-12 13:46:52.307080+0800 10-掌握-NSOperation操作依赖和监听[3592:698517] 并行队列同步步执行 1 --- {number = 1, name = main}
2018-11-12 13:46:52.307330+0800 10-掌握-NSOperation操作依赖和监听[3592:698517] 并行队列同步步执行 2 --- {number = 1, name = main}
2018-11-12 13:46:52.307482+0800 10-掌握-NSOperation操作依赖和监听[3592:698517] 并行队列同步步执行 3 --- {number = 1, name = main}
2018-11-12 13:46:52.307626+0800 10-掌握-NSOperation操作依赖和监听[3592:698517] 并行队列同步步执行 4 --- {number = 1, name = main}
*/
dispatch_queue_t concurrentQ = dispatch_queue_create("com.lekan.concurrentQ", DISPATCH_QUEUE_CONCURRENT);
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
for (NSInteger i=1; i<5; i++) {
dispatch_sync(concurrentQ, ^{
NSLog(@"并行队列同步步执行 %zd --- %@",i,[NSThread currentThread]);
});
}
});
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
for (NSInteger i=1; i<5; i++) {
dispatch_sync(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
NSLog(@"并行队列同步执行 %zd --- %@",i,[NSThread currentThread]);
});
}
});
/*
2018-11-12 13:55:50.769248+0800 10-掌握-NSOperation操作依赖和监听[3694:725498] 并行队列同步步执行 1 --- {number = 3, name = (null)}
2018-11-12 13:55:50.769531+0800 10-掌握-NSOperation操作依赖和监听[3694:725498] 并行队列同步步执行 2 --- {number = 3, name = (null)}
2018-11-12 13:55:50.769701+0800 10-掌握-NSOperation操作依赖和监听[3694:725498] 并行队列同步步执行 3 --- {number = 3, name = (null)}
2018-11-12 13:55:50.769862+0800 10-掌握-NSOperation操作依赖和监听[3694:725498] 并行队列同步步执行 4 --- {number = 3, name = (null)}
*/
并发队列异步执行,开辟多个新线程,并且线程会重用,无序执行
for (NSInteger i=1; i<6; i++) {
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
NSLog(@"并行队列异步执行 %zd --- %@",i,[NSThread currentThread]);
});
}
dispatch_queue_t concurrentQ = dispatch_queue_create("com.lekan.concurrentQ", DISPATCH_QUEUE_CONCURRENT);
for (NSInteger i=0; i<5; i++) {
dispatch_async(concurrentQ, ^{
NSLog(@"并行队列异步执行 %zd --- %@",i,[NSThread currentThread]);
});
}
/*
2018-11-12 14:18:06.099636+0800 10-掌握-NSOperation操作依赖和监听[3918:779339] 并行队列异步执行 3 --- {number = 5, name = (null)}
2018-11-12 14:18:06.099680+0800 10-掌握-NSOperation操作依赖和监听[3918:779340] 并行队列异步执行 4 --- {number = 6, name = (null)}
2018-11-12 14:18:06.099711+0800 10-掌握-NSOperation操作依赖和监听[3918:779338] 并行队列异步执行 2 --- {number = 4, name = (null)}
2018-11-12 14:18:06.099713+0800 10-掌握-NSOperation操作依赖和监听[3918:778176] 并行队列异步执行 1 --- {number = 3, name = (null)}
2018-11-12 14:18:06.099997+0800 10-掌握-NSOperation操作依赖和监听[3918:779339] 并行队列异步执行 5 --- {number = 5, name = (null)}
*/
主队列异步执行,不开辟新的线程,顺序执行
主队列：专门负责调度主线程度的任务，没有办法开辟新的线程。所以，在主队列下的任务不管是异步任务还是同步任务都不会开辟线程，任务只会在主线程顺序执行。
主队列异步任务：现将任务放在主队列中，但是不是马上执行，等到主队列中的其它所有除我们使用代码添加到主队列的任务都执行完毕之后才会执行我们使用代码添加的任务。
dispatch_async(dispatch_get_main_queue(), ^{
NSLog(@"1 --- %@",[NSThread currentThread]);
});
dispatch_async(dispatch_get_main_queue(), ^{
NSLog(@"2 --- %@",[NSThread currentThread]);
});
dispatch_async(dispatch_get_main_queue(), ^{
NSLog(@"3 --- %@",[NSThread currentThread]);
});
/*
2018-11-12 10:46:15.960763+0800 10-掌握-NSOperation操作依赖和监听[2068:312401] 1 --- {number = 1, name = main}
2018-11-12 10:46:15.961174+0800 10-掌握-NSOperation操作依赖和监听[2068:312401] 2 --- {number = 1, name = main}
2018-11-12 10:46:15.961430+0800 10-掌握-NSOperation操作依赖和监听[2068:312401] 3 --- {number = 1, name = main}
*/
主队列同步执行,会造成死锁('主线程'和'主队列'相互等待,卡住主线程)
专门负责调度主线程度的任务，没有办法开辟新的线程。所以，在主队列下的任务不管是异步任务还是同步任务都不会开辟线程，任务只会在主线程顺序执行。
dispatch_sync(dispatch_get_main_queue(), ^{
NSLog(@"主队列同步执行 : %@",[NSThread currentThread]);
});
4.线程间通讯
经典用法 : 子线程进行耗时操作, 主线程刷新UI
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
//进行耗时操作
NSLog(@"1 --- %@",[NSThread currentThread]);
//回到主线程,执行刷新UI操作
dispatch_sync(dispatch_get_main_queue(), ^{
NSLog(@"2 -- %@",[NSThread currentThread]);
});
});
1.延迟操作
- 调用NSObject方法:
[self performSelector:<#(nonnull SEL)#> withObject:<#(nullable id)#> afterDelay:<#(NSTimeInterval)#>]
- GCD函数实现延时执行:
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(<#delayInSeconds#> * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
<#code to be executed after a specified delay#>
});
1.队列组的使用
- 项目需求: 首先分别异步执行两个耗时操作;其次等两次耗时操作都执行完毕后,再回到主线程执行操作,使用队列组
dispatch_group_t快速,高效的实现上述需求.
dispatch_group_t group = dispatch_group_create();
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_group_async(group, queue, ^{
//耗时操作1
});
dispatch_group_async(group, queue, ^{
//耗时操作2
});
dispatch_group_notify(group, dispatch_get_main_queue(), ^{
//主线程刷新UI
});
若需求是耗时操作顺序执行,则将任务放到串行队列中,自然就是按顺序执行
dispatch_group_t group = dispatch_group_create();
dispatch_queue_t serialQueue = dispatch_queue_create("com.lekan.serialQueue", DISPATCH_QUEUE_SERIAL);
dispatch_group_async(group, serialQueue, ^{
//耗时操作1
});
dispatch_group_async(group, serialQueue, ^{
//耗时操作2
});
dispatch_group_notify(group, dispatch_get_main_queue(), ^{
//主线程刷新UI
});
GCD内部怎么实现的
- iOS和OS X的核心是XNU内核,GCD是基于XNU内核实现的
- GCD的API全部在libdispatch库中
- GCD的底层实现主要有Dispatch Queue 和 Dispatch Source
- Dispatch Queue: 管理block(操作)
- Dispatch Source: 处理事件(MACH端口发送,MACH端口接收,检测与进程相关事件等10种事件)iOS多线程——Dispatch Source
10种事件png
GCD的queue,main queue中执行的代码一定是在main thread么?
- 对于queue中所执行的代码不一定在main thread中.如果queue是在主线程中创建的,那么所执行的代码就是在主线程中执行.如果是在子线程中创建的,那么就不会在main thread中执行.
- 对于main queue就是在主线程中的,因此一定会在主线程中执行.获取main queue就可以了,不需要创建,获取方式通过调用方法dispatch_get_main_queue()来获取.
苹果为什么要废弃dispatch_get_current_queue?
- dispatch_get_current_queue容易造成死锁.
#######如果让你来实现dispatch_once,你会怎么做? - GCD外传：dispatch_once(上)
- GCD外传：dispatch_once(中)
- 深入浅出GCD之dispatch_once