关于GCD的一些用法

/*----------------GCD延迟调用------------*/

/*
void
dispatch_after(dispatch_time_t when,//什么时候执行延迟调用的代码
dispatch_queue_t queue,//执行的任务放到哪个队列
dispatch_block_t block);//具体执行的任务
*/

//代码执行到此处的时间
CFAbsoluteTime now = CFAbsoluteTimeGetCurrent();
//延迟两秒
dispatch_time_t time = dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2 * NSEC_PER_SEC));

dispatch_after(time, dispatch_get_main_queue(), ^{
NSLog(@"subTime is %f", CFAbsoluteTimeGetCurrent() - now);
});

//异步线程要写runloop，否则还没执行就运行结束了。。。。
[[NSRunLoop currentRunLoop] run];

/*--------------dispatch_group_async的使用------------*/

//dispatch_group_async 执行多个任务都结束后的一个全部结束的处理，用来监视一组block对象的完成

//创建group
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, ^{
sleep(5);
NSLog(@"block1");
});

dispatch_group_async(group, queue, ^{
NSLog(@"block2");
});

dispatch_group_async(group, queue, ^{
NSLog(@"block3");
});

//结果汇总，所有任务执行结束汇总，不阻塞当前进程
dispatch_group_notify(group, queue, ^{
NSLog(@"group end");
});

//对block中的时间永久等待
//        dispatch_time_t time = DISPATCH_TIME_FOREVER;
//等待所有的任务结束，中途不得取消，阻塞当前进程
//        dispatch_group_wait(group, time);

dispatch_time_t time = dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2 * NSEC_PER_SEC));

long result = dispatch_group_wait(group, time);
if (result == 0) {
NSLog(@"任务全部结束");
} else {
NSLog(@"还有任务没有结束");
}

NSLog(@"END");

/*------------dispatch_apply的使用-----------*/
//dispatch_apply按指定的次数将指定的block追加到dispatch queue中，并等待全部处理执行结束，可实现高性能的循环迭代
NSArray *arr = @[@0, @1, @2, @3, @4, @5, @6];
dispatch_async(queue, ^{
//使用dispatch_apply的执行效率比for高
dispatch_apply([arr count], queue, ^(size_t index) {
NSLog(@"%zu----%@", index, arr[index]);
});

//执行更新
dispatch_async(dispatch_get_main_queue(), ^{
NSLog(@"done");
});
});

//-------信号量dispatch_semaphore的使用---------

NSMutableArray *mArr = [NSMutableArray array];

//创建信号量,参数取决与线程数量
dispatch_semaphore_t semaphore = dispatch_semaphore_create(1);

for (int i = 0; i < 100000; i++) {
dispatch_async(queue, ^{

//等待,等待条件：如果信号量>0,则不需要等待直接往下执行，但是信号量-1, 反之则等待
dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);

[mArr addObject:@(i)];

//发信号，使原来的信号量计数值+1
dispatch_semaphore_signal(semaphore);

});
}

//这时可能数据还没完全加载，需要延迟调用
NSLog(@"count is %ld", mArr.count);

//延迟执行
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(5 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{

//验证是否全部加载
NSLog(@"mArr.count is %ld", mArr.count);

//验证是否有重复
NSSet *set = [NSSet setWithArray:mArr];
NSLog(@"set.count is %ld", set.count);
});

//-------------多线程并发控制------------------

dispatch_semaphore_t semaphore = dispatch_semaphore_create(3);//3个并行数
dispatch_group_t group = dispatch_group_create();

for (int i = 0; i < 10; i ++) {
dispatch_group_async(group, queue, ^{
//永久等待程序执行
dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);

NSLog(@"%d", i);

sleep(1
);

//发送信号,信号量+1
dispatch_semaphore_signal(semaphore);
});
}

//永久等待，不需要再写runloop
dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
NSLog(@"END");