Grand Central Dispatch(GCD)是异步执行任务的技术之一。一般将应用程序中记述的线程管理用

的代码在系统级中实现。开发者只需要定义想执行的任务并追加到适当的Dispatch Queue中,GCD就能生成

必要的线程并计划执行任务。由于线程管理是作为系统的一部分来实现的,因此可以统一管理,也可以执行任务,

这样就比以前的线程更有效率。

GCD API

1. Dispatch Queue 队列

队列有两种类型:

Serial Dispatch Queue 串行队列,使用一个线程,按照追加的顺序(先进先出FIFO)执行处理。多个串行队列之间是并行处理的。
Concurrent Dispatch Queue 并行队列,使用多个线程,并发处理

2.diapatch_queue_create

创建 Serial Queue:

dispatch_queue_t mySerailQueue = dispatch_queue_create("com.r.dispatchSerailQueue", DISPATCH_QUEUE_SERIAL);

dispatch_queue_t myConcurrentQueue = dispatch_queue_create("com.r.dispatchConcurrentQueue", DISPATCH_QUEUE_CONCURRENT);

第一个参数是指定 Serial dispatch queue 的名称。该名称在Xcode和Instruments的调试器中作为Dispatch Queue名称.

第二个参数是生成Dispatch Queue的类型,如果是NULL 或者 DISPATCH_QUEUE_SERIAL生成串行队列,

指定为DISPATCH_QUEUE_CONCURRENT生成并发队列.

3.Main Dispatch Queue/Global Dispatch Queue

获取系统标准提供的Dispatch Queue。

Main Dispatch Queue是在主线程执行的dispatch queue, Main Dispatch Queue是一个Serail Dispatch Queue。追加到Main Dispatch Queue的处理在主线程的RunLoop中执行。一般将用户界面更新等必需要在主线程中执行的处理追加到Main Dispatch Queue中。

Global Dispatch Queue是所有应用程序都能过使用的Concurrent Dispatch Queue。没有必要通过dispatch_queue_create函数逐个创建Concurrent Dispatch Queue,只要获取Global Dispatch Queue使用即可。Global Dispatch Queue有四个优先级

Main Dispatch QueueSerial Dispatch Queue主线程执行
Global Dispatch Queue(High Priority)Concurrent Dispatch queue执行优先级:高(最高)
Global Dispatch Queue(Default Priority)Concurrent Dispatch queue执行优先级:默认
Global Dispatch Queue(Low Priority)Concurrent Dispatch queue执行优先级:低
Global Dispatch Queue(Background Priority)Concurrent Dispatch queue执行优先级:后台

获取Dispatch Queue方法:

dispatch_queue_t mainDispatchQueue = dispatch_get_main_queue();

dispatch_queue_t globalDispatchQueueHigh = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, );

使用Main Dispatch Queue 和 Global Dispatch Queue

dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, ), ^{

        /**
* 可并行处理的任务TODO
*/ dispatch_async(dispatch_get_main_queue(), ^{
/**
* 主线程执行
*/
});
});

4. dispatch_after

dispatch_after表示在指定的时间之后追加处理到Dispatch Queue。并不是指定时间后执行处理。

dispatch_time_t time = dispatch_time(DISPATCH_TIME_NOW, 3ull*NSEC_PER_SEC);
dispatch_after(time, dispatch_get_main_queue(), ^{
NSLog(@"等待3秒后执行");
});

虽然在有严格时间到要求下使用时会出现问题,但在大致延迟执行处理时,该函数还是有效的。

5.dispatch_suspend/dispatch_resume

当追加大量处理到Dispatch Queue时,在追加处理到过程中,有时希望不执行已追加的处理。在这种情况下只要挂起Dispatch Queue即可。

dispatch_suspend 函数挂起指定的Dispatch Queue

dispatch_resume 函数恢复指定的Dispatch Queue

这些函数对已经执行的处理没有影响,挂起后,追加到Dispatch Queue中处理在此之后暂停执行,而恢复使得这些处理继续执行。

6.Dispatch Group

在追加到Dispatch Queue中的多个处理全部结束后想执行结束处理.

dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, );
dispatch_group_t group = dispatch_group_create();
dispatch_group_async(group, queue, ^{
for (int i=; i<; i++) {
NSLog(@"");
}
});
dispatch_group_async(group, queue, ^{
for (int i=; i<; i++) {
NSLog(@"");
}
});
dispatch_group_async(group, queue, ^{
for (int i=; i<; i++) {
NSLog(@"");
}
});
//最后执行4444
dispatch_group_notify(group, dispatch_get_main_queue(), ^{
NSLog(@"");
});
NSLog(@"");

7. dispatch_barrier_async

   dispatch_async(queue, ^{
//读文件
});
dispatch_async(queue, ^{
//读文件
}); //使用dispatch_barrier_async避免数据竞争
dispatch_barrier_async(queue, ^{
//写文件
});
dispatch_async(queue, ^{
//读文件
});
dispatch_async(queue, ^{
//读文件
});

一个dispatch barrier 允许在一个并发队列中创建一个同步点。当在并发队列中遇到一个barrier, 他会延迟执行barrier的block,

等待所有在barrier之前提交的blocks执行结束。 这时,barrier block自己开始执行。 之后, 队列继续正常的执行操作。

调用这个函数总是在barrier block被提交之后立即返回,不会等到block被执行。当barrier block到并发队列的最前端,

他不会立即执行。相反,队列会等到所有当前正在执行的blocks结束执行。到这时,barrier才开始自己执行。

所有在barrier block之后提交的blocks会等到barrier block结束之后才执行

这里指定的并发队列应该是自己通过dispatch_queue_create函数创建的。

如果你传的是一个串行队列或者全局并发队列,这个函数等同于dispatch_async函数。

8.dispatch_apply

dispatch_apply函数是dispatch_sync函数和Dispatch Group的关联API。

该函数按指定的次数将指定的Block追加到Dispatch Queue中,并等待全部处理执行结束。

 dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, );
dispatch_apply(, queue, ^(size_t index) {
NSLog(@"%zu", index);//并行
});
//最后执行
NSLog(@"");

9. Dispatch Semaphore

信号量:就是一种可用来控制访问资源的数量的标识,设定了一个信号量,在线程访问之前,加上信号量的处理,则可告知系统按照我们指定的信号量数量来执行多个线程。

 dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, );

     /**
* 生成Dispatch Semaphore
* Dispatch Semaphore 的计数初始值设定为1
* 保证可访问NSMutableArray类对象的线程同时只有一个
*/
dispatch_semaphore_t semaphore = dispatch_semaphore_create();
NSMutableArray *array = [[NSMutableArray alloc] init]; for (int i=; i<; i++) {
dispatch_async(queue, ^{
/**
* 等待Dispatch Semaphore
一直等待,直到Dispatch Semaphore 的计数的值达到大于等于1
*/
dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER); /**
* 由于Dispatch Semaphore 的计数达到大于等于1
所以Dispatch Semaphore 的计数值减去1
dispatch_semaphore_wait函数执行返回 即执行到此时Dispatch Semaphore的计数值恒为00 由于可访问NSMutableArray类对象的线程数只有1个
因此可安全的进行更新
*/
[array addObject:[NSNumber numberWithInt:i]]; /**
* 排他控制处理结束
所以通过dispatch_semaphore_signal函数
将DispatchSemaphore的计数值加1
如果有通过dispatch_semaphore_wait函数
等待Dispatch Semaphore的计数值增加的线程
就由最先等待的线程执行。
*/
dispatch_semaphore_signal(semaphore);
});
}
05-11 19:44