image.png
今天看到了这么个例子
dispatch_source_t source = dispatch_source_create(DISPATCH_SOURCE_TYPE_DATA_ADD, 0, 0, dispatch_get_main_queue());
__block NSUInteger totalComplete = 0;
dispatch_source_set_event_handler(source, ^{
//当处理事件被最终执行时，计算后的数据可以通过dispatch_source_get_data来获取。这个数据的值在每次响应事件执行后会被重置，所以totalComplete的值是最终累积的值。
NSUInteger value = dispatch_source_get_data(source);
totalComplete += value;
NSLog(@"进度：%@", @((CGFloat)totalComplete/100));
NSLog(@":large_blue_circle:线程号：%@", [NSThread currentThread]);
});
//分派源创建时默认处于暂停状态，在分派源分派处理程序之前必须先恢复。
dispatch_resume(source);
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
//2、恢复源后，就可以通过dispatch_source_merge_data向Dispatch Source(分派源)发送事件:
for (NSUInteger index = 0; index < 100; index++) {
dispatch_async(queue, ^{
dispatch_source_merge_data(source, 1);
NSLog(@":recycle:线程号：%@~~~~~~~~~~~~i = %ld", [NSThread currentThread], index);
usleep(20000);//0.02秒
});
}
当下面的异步队列跑完以后才会回调到上面的dispatch_source_set_event_handler中执行，并且只会执行一次。感觉挺有意思，so 查了下dispatch_source的详细资料。
首先看dispatch_source_t的创建方法
dispatch_source_t source = dispatch_source_create(dispatch_source_type_t type, uintptr_t handle, unsigned long mask, dispatch_queue_t queue)
四个参数意思：type: dispatch源可处理的事件
handle:可以理解为句柄、索引或id，假如要监听进程，需要传入进程的ID,
mask: 可以理解为描述，提供更详细的描述，让它知道具体要监听什么
queue:自定义源需要的一个队列，用来处理所有的响应句柄（block)
dispatch_source_t source = dispatch_source_create(DISPATCH_SOURCE_TYPE_DATA_ADD, 0, 0, dispatch_get_main_queue());
上面看到的例子就是用到DISPATCH_SOURCE_TYPE_DATA_ADD,
当同一时间，一个事件的的触发频率很高，那么Dispatch Source会将这些响应以ADD的方式进行累积，然后等系统空闲时最终处理，如果触发频率比较零散，那么Dispatch Source会将这些事件分别响应。
看下里面的dispatch_source涉及的一些方法
dispatch_suspend(queue) //挂起队列
dispatch_resume(source) //分派源创建时默认处于暂停状态，在分派源分派处理程序之前必须先恢复
dispatch_source_merge_data //向分派源发送事件，需要注意的是，不可以传递0值(事件不会被触发)，同样也不可以传递负数。
dispatch_source_set_event_handler //设置响应分派源事件的block，在分派源指定的队列上运行
dispatch_source_get_data //得到分派源的数据
uintptr_t dispatch_source_get_handle(dispatch_source_t source); //得到dispatch源创建，即调用dispatch_source_create的第二个参数
unsigned long dispatch_source_get_mask(dispatch_source_t source); //得到dispatch源创建，即调用dispatch_source_create的第三个参数
void dispatch_source_cancel(dispatch_source_t source); //取消dispatch源的事件处理--即不再调用block。如果调用dispatch_suspend只是暂停dispatch源。
long dispatch_source_testcancel(dispatch_source_t source); //检测是否dispatch源被取消，如果返回非0值则表明dispatch源已经被取消
void dispatch_source_set_cancel_handler(dispatch_source_t source, dispatch_block_t cancel_handler); //dispatch源取消时调用的block，一般用于关闭文件或socket等，释放相关资源
void dispatch_source_set_registration_handler(dispatch_source_t source, dispatch_block_t registration_handler); //可用于设置dispatch源启动时调用block，调用完成后即释放这个block。也可在dispatch源运行当中随时调用这个函数。
示例
第一种当然就是我们用的最多的倒计时。
dispatch_source_t timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, <#dispatchQueue#>);
dispatch_source_set_timer(timer, DISPATCH_TIME_NOW, <#intervalInSeconds#> * NSEC_PER_SEC, <#leewayInSeconds#> * NSEC_PER_SEC);
dispatch_source_set_event_handler(timer, ^{
<#code to be executed when timer fires#>
});
dispatch_resume(timer);
第二种 挂起
//创建DISPATCH_QUEUE_SERIAL队列
dispatch_queue_t queue1 = dispatch_queue_create("com.butterfly.queue1", 0);
dispatch_queue_t queue2 = dispatch_queue_create("com.butterfly.queue2", 0);
//创建group
dispatch_group_t group = dispatch_group_create();
//异步执行任务
dispatch_async(queue1, ^{
NSLog(@"任务 1 ： queue 1...");
sleep(1);
NSLog(@":white_check_mark:完成任务 1");
});
dispatch_async(queue2, ^{
NSLog(@"任务 1 ： queue 2...");
sleep(1);
NSLog(@":white_check_mark:完成任务 2");
});
//将队列加入到group
dispatch_group_async(group, queue1, ^{
NSLog(@":no_entry_sign:正在暂停 1");
dispatch_suspend(queue1);
});
dispatch_group_async(group, queue2, ^{
NSLog(@":no_entry_sign:正在暂停 2");
dispatch_suspend(queue2);
});
//等待两个queue执行完毕后再执行
dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
NSLog(@"＝＝＝＝＝＝＝等待两个queue完成, 再往下进行...");
//异步执行任务
dispatch_async(queue1, ^{
NSLog(@"任务 2 ： queue 1");
});
dispatch_async(queue2, ^{
NSLog(@"任务 2 ： queue 2");
});
//在这里将这两个队列重新恢复
dispatch_resume(queue1);
dispatch_resume(queue2);
打印
2018-10-22 11:46:59.866358+0800 threadTest[82654:2979588] 任务 1 ： queue 1...
2018-10-22 11:46:59.866359+0800 threadTest[82654:2979589] 任务 1 ： queue 2...
2018-10-22 11:47:00.871468+0800 threadTest[82654:2979589] :white_check_mark:完成任务 2
2018-10-22 11:47:00.871468+0800 threadTest[82654:2979588] :white_check_mark:完成任务 1
2018-10-22 11:47:00.871744+0800 threadTest[82654:2979589] :no_entry_sign:正在暂停 2
2018-10-22 11:47:00.871750+0800 threadTest[82654:2979588] :no_entry_sign:正在暂停 1
2018-10-22 11:47:00.871915+0800 threadTest[82654:2979462] ＝＝＝＝＝＝＝等待两个queue完成, 再往下进行...
2018-10-22 11:47:00.872083+0800 threadTest[82654:2979588] 任务 2 ： queue 1
2018-10-22 11:47:00.872099+0800 threadTest[82654:2979589] 任务 2 ： queue 2
我们可以看到，当我们挂起队列的时候只要是没有dispatch_resume，则队列就不会执行，即使是异步的。
