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，则队列就不会执行，即使是异步的。

ios自习室欢迎进入，一起学习一起进步。

IMG_7291.JPG