Grand Central Dispatch（GCD）
1.Dispatch Queue
| Dispath Queue 的种类 | 说明 |
|---|---|
| Serial Dispatch Queue(串行队列) | 等待现在执行中处理结束 |
| Concurrent Dispatch Queue（并发队列） | 不等待现在执行中处理结束 |
1.1 dispatch_queue_create
dispatch_queue_t myQueue = dispatch_queue_create("com.example.gcd.myQueue", NULL);
第一个参数指定Serial Dispatch Queue的名称，推荐使用bundleId这样的逆序全程域名
-
如果生成串行队列第二个参数指定为
NULL，如果生成并发队列指定为DISPATCH_QUEUE_CONCURRENT⚠️注意！通过含有create的函数生成的对象在使用结束后都需要通过
dispatch_release函数释放
直接获取系统的Serial Dispatch Queue：dispatch_get_main_queue()和Concurrent Dispatch Queue：dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0)
dispatch_queue_t serailQueue = dispatch_get_main_queue(); // 主队列 串行队列
dispatch_async(serailQueue, ^{
sleep(2);
NSLog(@"1 -- thread == %@",[NSThread currentThread]);
});
dispatch_async(serailQueue, ^{
NSLog(@"2 -- thread == %@",[NSThread currentThread]);
});
dispatch_async(serailQueue, ^{
NSLog(@"3 -- thread == %@",[NSThread currentThread]);
});
dispatch_async(serailQueue, ^{
NSLog(@"4 -- thread == %@",[NSThread currentThread]);
});
dispatch_queue_t concurrentQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0); // 全局队列 并发队列
dispatch_async(concurrentQueue, ^{
sleep(2);
NSLog(@"6-- thread == %@",[NSThread currentThread]);
});
dispatch_async(concurrentQueue, ^{
NSLog(@"7 -- thread == %@",[NSThread currentThread]);
});
dispatch_async(concurrentQueue, ^{
NSLog(@"8 -- thread == %@",[NSThread currentThread]);
});
dispatch_async(concurrentQueue, ^{
NSLog(@"9 -- thread == %@",[NSThread currentThread]);
});
打印结果
2020-01-02 15:08:24.327030+0800 Test[5227:2097148] 7 -- thread == {number = 3, name = (null)} //因为6睡眠了2s，所以 7 8 9 先打印
2020-01-02 15:08:24.327090+0800 Test[5227:2097148] 8 -- thread == {number = 3, name = (null)}
2020-01-02 15:08:24.327119+0800 Test[5227:2097148] 9 -- thread == {number = 3, name = (null)}
2020-01-02 15:08:26.332363+0800 Test[5227:2097147] 6-- thread == {number = 6, name = (null)} // 6睡眠2s后，1也睡眠2s结束 所以6和1 同时打印，234 依次打印
2020-01-02 15:08:26.334294+0800 Test[5227:2097127] 1 -- thread == {number = 1, name = main}
2020-01-02 15:08:26.334626+0800 Test[5227:2097127] 2 -- thread == {number = 1, name = main}
2020-01-02 15:08:26.334893+0800 Test[5227:2097127] 3 -- thread == {number = 1, name = main}
2020-01-02 15:08:26.335291+0800 Test[5227:2097127] 4 -- thread == {number = 1, name = main}
可以看到，处于并发队列中的6 7 8 9 都开启了新的线程，1 2 3 4 还是处于主线程中。
1.2 dispatch_set_target
通过dispatch_queue_create创建的queue执行优先级跟系统默认的优先级一样，使用dispatch_set_target来变更Queue的执行优先级
dispatch_queue_t queue = dispatch_queue_create("com.example.gcd.myQueue", DISPATCH_QUEUE_CONCURRENT);
dispatch_queue_t queue1 = dispatch_queue_create("com.example.gcd.myQueue1", DISPATCH_QUEUE_CONCURRENT);
// 变更优先级
//dispatch_set_target_queue(queue, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_LOW, 0)); //将queue的优先级降低
dispatch_async(queue, ^{
NSLog(@"1 -- thread == %@",[NSThread currentThread]);
});
dispatch_async(queue1, ^{
NSLog(@"2 -- thread == %@",[NSThread currentThread]);
});
dispatch_release(queue);
dispatch_release(queue1);
打印结果：
2020-01-02 16:15:34.513958+0800 Test[5260:2108203] 1 -- thread == {number = 4, name = (null)}
2020-01-02 16:15:34.514032+0800 Test[5260:2108203] 2-- thread == {number = 4, name = (null)}
// 变更执行优先级后
2020-01-02 16:19:21.934330+0800 Test[5275:2109810] 2-- thread == {number = 6, name = (null)}
2020-01-02 16:19:21.937130+0800 Test[5275:2109810] 1 -- thread == {number = 6, name = (null)}
1.3 dispatch_after
指定3秒后将指定的Block追加到Main Dispatch Queue中，代码如下:
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(3 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
NSLog(@"waited at least three seconds");
});
⚠️需要注意的是，dispatch_after函数并不是在指定时间后执行处理，而是在指定时间追加处理到Dispatch Queue。
- 第一个参数是指定时间用的dispatch_time_t类型的值，该值使用dispatch_time函数或者dispatch_walltime函数作成。
- 第二个参数是指定队列
- 执行的代码块
2. Dispatch Group
当队列中的多个任务处理结束才执行某些操作时，使用Dispatch Group可以很方便的完成。
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, ^{
NSLog(@"1");
});
dispatch_group_async(group, queue, ^{
sleep(2);
NSLog(@"2");
});
dispatch_group_notify(group, queue, ^{
NSLog(@"finish");
});
dispatch_release(group);
// 打印结果
2020-01-02 17:38:15.197578+0800 Test[5304:2124319] 1
2020-01-02 17:38:17.201227+0800 Test[5304:2124316] 2
2020-01-02 17:38:17.201586+0800 Test[5304:2124321] finish // 当2打印后队列中的任务完成，打印finish
⚠️需要注意的是，dispatch_group_notify只关心队列中的任务是否完成，不会关心是否是异步任务。如果需要等到队列中的异步任务完成后再执行下一步操作可配合dispatch_group_enter(group)和dispatch_group_leave(group)进行。
例如将任务2换成一个异步任务：
dispatch_group_async(group, queue, ^{
dispatch_async(queue, ^{
sleep(2);
NSLog(@"2");
});
});
// 打印结果
2020-01-02 17:47:08.139217+0800 Test[5311:2125947] 1
2020-01-02 17:47:08.139341+0800 Test[5311:2125945] finish
2020-01-02 17:47:10.144397+0800 Test[5311:2125947] 2
// 可以看到任务1完成后 直接打印了finish，这里并不是说没有执行任务2，只不过因为任务2是一个异步任务，调用完任务2后，任务2开启异步线程开始睡眠，队列执行完毕打印finish。2s后任务2中的异步任务执行完成打印2.
2.1 dispatch_group_enter()和dispatch_group_leave()
dispatch_group_enter 和 dispatch_group_leave 一般是成对出现的, 进入一次，就得离开一次。也就是说，当离开和进入的次数相同时，就代表任务组完成了。如果enter比leave多，那就是没完成，如果leave调用的次数多了， 会崩溃的；通常dispatch_group_enter()和dispatch_group_leave()用于网络通信中。
我们在上面的例子中加入dispatch_group_enter()和dispatch_group_leave()
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_group_t group = dispatch_group_create();
dispatch_group_enter(group);
dispatch_group_async(group, queue, ^{
NSLog(@"1");
dispatch_group_leave(group);
});
dispatch_group_enter(group);
dispatch_group_async(group, queue, ^{
dispatch_async(queue, ^{
sleep(2);
NSLog(@"2");
dispatch_group_leave(group);
});
});
dispatch_group_notify(group, queue, ^{
NSLog(@"finish");
});
dispatch_release(group);
2020-01-08 20:17:59.868014+0800 Test[6638:2555431] 1
2020-01-08 20:18:01.874152+0800 Test[6638:2555431] 2
2020-01-08 20:18:01.874416+0800 Test[6638:2555431] finish // 可以看到加入dispatch_group_enter(group)和dispatch_group_leave(group)后，等待2执行完成后才执行finish
2.2 dispatch_barrier_async
dispatch_barrier_async函数会等待追加到Concurrent Dispatch Queue上的并行执行的处理全部结束之后，再将指定的处理追加到改队列中，然后再等dispatch_barrier_async函数追加的处理执行完毕后，队列才恢复为一般动作，追加到该队列的处理又开始并执行。
⚠️注意 dispatch_barrier_async只能搭配自定义并行对列dispatch_queue_t使用。不能使用dispatch_get_global_queue,否则dispatch_barrier_async的作用和dispatch_async的作用一模一样.
dispatch_queue_t queue = dispatch_queue_create("com.example.gcd.myQueue",DISPATCH_QUEUE_CONCURRENT);
dispatch_async(queue, ^{
NSLog(@"1");
});
dispatch_barrier_async(queue, ^{
sleep(2);
NSLog(@"3");
});
dispatch_async(queue, ^{
NSLog(@"2");
});
//打印结果
2020-01-03 09:34:37.240138+0800 Test[5362:2163237] 1
2020-01-03 09:34:39.245367+0800 Test[5362:2163237] 3 // 打印完1后，2s后打印3跟2
2020-01-03 09:34:39.245688+0800 Test[5362:2163237] 2
2.3 dispatch_sync
既然有“async”，当然也就有“sync”，即dispatch_sync函数。它意味着“同步”(synchronous)，也就是将指定的Block“同步”追加到指定的Dispatch Queue中。在追加Block结束前，dispatch_sync函数会一直等待。
⚠️注意：异步并发会开启新线程，异步串行只会开启一条新线程（所有的异步任务都在同一个线程排队执行），同步函数都在主队列中执行（不管是串行还是并发）。主队列同步任务会导致死锁
2.4 dispatch_apply
dispatch_apply函数是dispatch_sync函数和Dispatch Group的关联API。该函数按指定的次数将指定的Block追加到指定的Dispatch Queue中，并等待全部处理执行结束。
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_apply(10, queue, ^(size_t index) {
NSLog(@"%zu",index);
});
NSLog(@"done");
// 打印结果
2020-01-08 15:19:09.761125+0800 Test[6253:2493707] 0
2020-01-08 15:19:09.761162+0800 Test[6253:2493707] 1
2020-01-08 15:19:09.761171+0800 Test[6253:2493707] 2
2020-01-08 15:19:09.761179+0800 Test[6253:2493707] 3
2020-01-08 15:19:09.761186+0800 Test[6253:2493707] 4
2020-01-08 15:19:09.761195+0800 Test[6253:2493707] 5
2020-01-08 15:19:09.761203+0800 Test[6253:2493707] 6
2020-01-08 15:19:09.761210+0800 Test[6253:2493707] 8
2020-01-08 15:19:09.761216+0800 Test[6253:2493707] 9
2020-01-08 15:19:09.761211+0800 Test[6253:2493725] 7
2020-01-08 15:19:09.761243+0800 Test[6253:2493707] done
因为在并发队列中执行，所以各个处理的时间不定。但是done肯定是在最后的输出的。这是因为dispath_apply函数会等待全部处理执行结束。
2.5 dispatch_suspend/dispatch_resume
dispatch_suspend(queue)：挂起指定的queue。挂起后，队列中尚未执行的处理在此之后停止执行。
dispatch_resume(queue)：恢复指定的queue。恢复后，停止执行的处理继续执行。
3. Dispatch Semaphore
Dispatch Semaphore 是持有计数的信号，该计数是多线程编程中的计数类型信号。所谓信号，类似于过马路时常用的手旗。可以通过时举起手旗，不可以通过时放下手旗。而在Dispatch Semaphore中，使用计数来实现该功能。计数为0时等待，计数为1或者大于1时，减去1而不等待。
创建方法：dispatch_semaphore_t semaphore = dispatch_semaphore_create(1);
等待方法：dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
dispatch_semaphore_wait函数等待的计数值大于等于1时，对该计数减1并返回。如果是0着等待。
计数加1:dispatch_semaphore_signal(semaphore);
例如将所有数据添加到NSMutableArray中。
NSMutableArray *array = [NSMutableArray new];
for (int i = 0; i < 100000; i++) {
dispatch_async(queue, ^{
[array addObject:@(i)];
});
}
// 因为使用并发队列更新数组，访问数组的线程有很多，很大概率会导致内存错误。
//如果使用Dispatch Semaphore
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_semaphore_t semaphore = dispatch_semaphore_create(1);
NSMutableArray *array = [NSMutableArray new];
for (int i = 0; i < 100000; i++) {
dispatch_async(queue, ^{
dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
//加上Dispatch Semaphore后，执行到此时的semaphore为0，能访问NSMutableArray对象的线程只有1个，可以安全的进行更新
[array addObject:@(i)];
//更新处理完成后，semaphore加1，上面等待的线程继续执行
dispatch_semaphore_signal(semaphore);
});
}
dispatch_release(semaphore);
4. dispatch_once
dispatch_once函数是保证在应用程序执行中只执行一次指定处理的API。
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
/*
* 初始化
*/
});
5. dispatch_source_t
常用的定时器操作
dispatch_source_t timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, dispatch_get_main_queue());
// 1s后开始执行 每2s重复一次
dispatch_source_set_timer(timer, DISPATCH_TIME_NOW, 2ull * NSEC_PER_SEC, 1ull * NSEC_PER_SEC);
dispatch_source_set_event_handler(timer, ^{
/**
执行处理事件
*/
//满足条件时取消定时器处理
//dispatch_source_cancel(timer);
});
// 定时器取消时的处理
dispatch_source_set_cancel_handler(timer, ^{
// 释放定时器
dispatch_release(timer);
});
//启动定时器
dispatch_resume(timer);