[OC学习笔记]Grand Central Dispatch

Posted 2022-03-29 Billy Miracle

一、GCD概要

（一）什么是GCD

什么是GCD？以下摘自苹果的官方说明。
Grand Central Dispatch（GCD）是异步执行任务的技术之一。一般将应用程序中记述的线程管理用的代码在系统级中实现。开发者只需要定义想执行的任务并追加到适当的Dispatch Queue中，GCD就能生成必要的线程并计划执行任务。由于线程管理是作为系统的一部分来实现的，因此可统一管理，也可执行任务，这样就比以前的线程更有效率。
也就是说，GCD用我们难以置信的非常简洁的记述方法，实现了极为复杂繁琐的多线程编程，可以说这是一项划时代的技术。下面是使用了GCD源代码的例子，虽然稍显抽象，但从中也能感受到GCD的威力。

dispatch async(queue, ^
	/*
	 *长时间处理
	 *例如AR用画像识别*例如数据库访问
	 */
	/*
	 *长时间处理结束， 主线程使用该处理结果。 
	 */
	dispatch_async(dispatch_get main_queue(), ^
		/*
		 *只在主线程可以执行的处理
		 *例如用户界面更新
		 */
	);
);

上面的就是在后台线程中执行长时间处理，处理结束时，主线程使用该处理结果的源代码。

dispatch_async(queue, ^

这仅有一行的代码让处理在后台线程中执行。

dispatch_async(dispatch_get main_queue(), ^

这样，仅此一行代码就能够让处理在主线程中执行。另外，大家看到“^”符号就能发现，GCD使用了“Blocks”，进一步简化了应用程序代码。
在导入GCD之前，Cocoa框架提供了NSObject类的performSelectorInBackground:withObject 实例方法和 performSelectorOnMainThread 实例方法等简单的多线程编程技术。
performSelector 系方法确实要比使用NSThread 类进行多线程编程简单，但与之前使用GCD的源代码相比，结果一目了然。相比performSelector系方法，GCD 更为简洁。如果使用GCD，不仅不必使用NSThread类或performSelector系方法这些过时的API，更可以通过GCD提供的系统级线程管理提高执行效率。真是到处都是优点呀。

（二）多线程编程

线程到底是什么呢?我们来温习一下。先看一下下面的Objective-C 源代码。

int main() 
	id o = [[MyObject alloc] init];
	[o execBlock];
	return 0;

虽然调用了几个方法，但代码行基本上是按从上到下的顺序执行的。那么，该源代码实际上在Mac或iPhone上是如何执行的呢？该源代码通过编译器转换为CPU命令列（二进制代码）。

略

汇集CPU命令列和数据，将其作为一个应用程序安装到 Mac 或 iPhone 上。
Mac、iPhone的操作系统OSXios根据用户的指示启动该应用程序后，首先便将包含在应用程序中的CPU命令列配置到内存中。CPU从应用程序指定的地址开始，一个一个地执行CPU命令列。先执行地址 lac 的命令列push，接着向后移动，执行地址 lae 的命令列 movw，再次向后移动，执行地址lb2的命令列，就这样不断循环下去。
在 Objective-C 的 if 语句和 for 语句等控制语句或函数调用的情况下，执行命令列的地址会远离当前的位置（位置迁移）。但是，由于一个CPU一次只能执行一个命令，不能执行某处分开的并列的两个命令，因此通过CPU执行的CPU命令列就好比一条无分叉的大道，其执行不会出现分歧。

这里所说的“1个CPU执行的CPU命令列为一条无分叉路径”即为“线程”。
现在一个物理的 CPU 芯片实际上有64个（64核）CPU，如果1个CPU核虚拟为两个CPU核工作，那么一台计算机上使用多个CPU核就是理所当然的事了。尽管如此，“1个CPU核执行的CPU 命令列为一条无分叉路径”仍然不变。
这种无分叉路径不只1条，存在有多条时即为“多线程”。在多线程中，1个CPU核执行多条不同路径上的不同命令。

虽然CPU的相关技术有很多，其进步也令人眼花缭乱，但基本上1个CPU核一次能够执行的CPU命令始终为1。那么怎样才能在多条路径中执行CPU命令列呢?
OS X和iOS 的核心XNU内核在发生操作系统事件时（如每隔一定时间，唤起系统调用等情况）会切换执行路径。执行中路径的状态，例如CPU的寄存器等信息保存到各自路径专用的内存块中，从切换目标路径专用的内存块中，复原CPU寄存器等信息，继续执行切换路径的 CPU命令列。这被称为“上下文切换”。
由于使用多线程的程序可以在某个线程和其他线程之间反复多次进行上下文切换，因此看上去就好像1个CPU核能够并列地执行多个线程一样。而且在具有多个 CPU核的情况下，就不是“看上去像”了，而是真的提供了多个CPU核并行执行多个线程的技术。
这种利用多线程编程的技术就被称为“多线程编程”。
但是，多线程编程实际上是一种易发生各种问题的编程技术。比如多个线程更新相同的资源会导致数据的不一致(数据竞争)、停止等待事件的线程会导致多个线程相互持续等待(死锁)、使用太多线程会消耗大量内存等。
当然，要回避这些问题有许多方法，但程序都偏于复杂。
尽管极易发生各种问题，也应当使用多线程编程。这是为什么呢？因为使用多线程编程可保证应用程序的响应性能。
应用程序在启动时，通过最先执行的线程，即“主线程”来描绘用户界面、处理触摸屏幕的事件等。如果在该主线程中进行长时间的处理，如 AR 用画像的识别或数据库访问，就会妨碍主线程的执行（阻塞）。在OS X和iOS 的应用程序中，会妨碍主线程中被称为RunLoop 的主循环的执行，从而导致不能更新用户界面、应用程序的画面长时间停滞等问题。
这就是长时间的处理不在主线程中执行而在其他线程中执行的原因。

使用多线程编程，在执行长时间的处理时仍可保证用户界面的响应性能。
GCD大大简化了偏于复杂的多线程编程的源代码。

二、GCD的API

（一）Dispatch Queue

首先回顾一下苹果官方对GCD的说明。
开发者要做的只是定义想执行的任务并追加到适当的 Dispatch Queue 中。
这句话用源代码表示如下:

dispatch_async(queue, ^
	/*
	 *想执行的任务
	 */
);

该源代码使用 Block 语法“定义想执行的任务”，通过dispatch_async 函数“追加”赋值在变量 queue 的“Dispatch Queue 中”。仅这样就可使指定的 Block 在另一线程中执行。
“Dispatch Queue”是什么呢？如其名称所示，是执行处理的等待队列。应用程序编程人员通过 dispatch_async 函数等 API，在 Block 语法中记述想执行的处理并将其追加到 Dispatch Queue 中。Dispatch Queue 按照追加的顺序（先进先出 FIFO，First-In-First-Out）执行处理。

另外在执行处理时存在两种Dispatch Queue，一种是等待现在执行中处理的 Serial Dispatch Queue，另一种是不等待现在执行中处理的 Concurrent Dispatch Queue。

Dispatch Queue种类	说明
Serial Dispatch Queue	等待现在执行中处理结束
Concurrent Dispatch Queue	不等待现在执行中处理结束

比较这两种 Dispatch Queue。准备以下源代码，在dispatch_async 中追加多个处理。

dispatch_async(queue,blk0);
dispatch_async(queue, blk1);
dispatch_async(queue,blk2);
dispatch_async(queue,blk3);
dispatch_async(queue,blk4);
dispatch_async(queue, blk5);
dispatch_async(queue,blk6);
dispatch_async(queue,blk7);

当变量 queue 为 Serial Dispatch Queue 时，因为要等待现在执行中的处理结束，所以首先执行blk0，blk0 执行结束后，接着执行 blk1，blk1 结束后再开始执行blk2，如此重复。同时执行的处理数只能有1个。即执行该源代码后，一定按照以下顺序进行处理。

blk0
blk1
blk2
blk3
blk4
blk5
blk6
blk7

当变量queue 为Concurrent Dispatch Queue 时，因为不用等待现在执行中的处理结束，所以首先执行bk0，不管bk0 的执行是否结束，都开始执行后面的blk1，不管 blk1 的执行是否结束，都开始执行后面的blk2，如此重复循环。
这样虽然不用等待处理结束，可以并行执行多个处理，但并行执行的处理数量取决于当前系统的状态。即 iOS 和 OS X基于Dispatch Queue 中的处理数、CPU 核数以及 CPU 负荷等当前系统的状态来决定 Concurrent Dispatch Queue 中并行执行的处理数。所谓“并行执行”，就是使用多个线程同时执行多个处理。

iOS 和 OS X 的核心–XNU 内核决定应当使用的线程数，并只生成所需的线程执行处理。另外，当处理结束，应当执行的处理数减少时，XNU 内核会结束不再需要的线程。XNU内核仅使用Concurrent Dispatch Queue 便可完美地管理并行执行多个处理的线程。
例如，前面的源代码，在多个线程中执行 Block。

线程0	线程1	线程2	线程3
blk0	blk1	blk2	blk3
blk4	blk6	blk5
blk7

假设准备4个Concurrent Dispatch Queue 用线程。首先blk0在线程0中开始执行，接着 blk1在线程1中、blk2在线程2中、blk3在线程3中开始执行。线程0中blk0执行结束后开始执行 blk4，由于线程1中blk1的执行没有结束，因此线程2中blk2执行结束后开始执行 blk5，就这样循环往复。
像这样在Concurrent Dispatch Queue 中执行处理时，执行顺序会根据处理内容和系统状态发生改变。它不同于执行顺序固定的Serial Dispatch Queue。在不能改变执行的处理顺序或不想并行执行多个处理时使用Serial Dispatch Queue。
虽然知道了有 Serial Dispatch Queue 和 Concurrent Dispatch Queue 这两种，但如何才能得到这些Dispatch Queue 呢？方法有两种。

（二）dispatch_queue_create

第一种方法是通过GCD的API生成Dispatch Queue。
通过 dispatch_queue_create 函数可生成 Dispatch Queue。以下源代码生成了 Serial Dispatch Queue。

dispatch_queue_t mySerialDispatchQueue = dispatch_queue_create("com.example.gcd.MySerialDispatchQueue", NULL);

在说明dispatch_queue_create 函数之前，先讲一下关于 Serial Dispatch Queue 生成个数的注意事项。如前所述，Concurrent Dispatch Queue 并行执行多个追加处理，而Serial Dispatch Queue 同时只能执行1个追加处理。虽然 Serial Dispatch Queue 和 Concurrent Dispatch Queue 受到系统资源的限制，但用dispatch_queue_create 函数可生成任意多个 Dispatch Queue。
当生成多个Serial Dispatch Queue 时，各个 Serial Dispatch Queue 将并行执行。虽然在1个Serial Dispatch Queue 中同时只能执行一个追加处理，但如果将处理分别追加到4个Serial Dispatch Queue 中，各个Serial Dispatch Queue 执行1个，即为同时执行4个处理。

以上是关于 Serial Dispatch Queue 生成个数注意事项的说明。一旦生成 Serial Dispatch Queue并追加处理，系统对于一个 Serial Dispatch Queue 就只生成并使用一个线程。如果生成2000个 Serial Dispatch Queue，那么就生成2000个线程。
像之前列举的多线程编程问题一样，如果过多使用多线程，就会消耗大量内存，引起大量的上下文切换，大幅度降低系统的响应性能。
只在为了避免多线程编程问题之一：多个线程更新相同资源导致数据竞争时使用 Serial Dispatch Queue。

但是Serial Dispatch Queue 的生成个数应当仅限所必需的数量。例如更新数据库时1个表生成1个Serial Dispatch Queue，更新文件时1个文件或是可以分割的1个文件块生成1个Serial Dispatch Queue。虽然“Serial Dispatch Queue 比Concurrent Dispatch Queue 能生成更多的线程”，但绝不能激动之下大量生成Serial Dispatch Queue。
当想并行执行不发生数据竞争等问题的处理时，使用Concurrent Dispatch Queue。而且对于 Concurrent Dispatch Queue 来说，不管生成多少，由于XNU内核只使用有效管理的线程，因此不会发生 Serial Dispatch Queue 的那些问题。
下面我们回来继续讲dispatch_queue_create 函数。该函数的第一个参数指定 Serial Dispatch Queue的名称。像此源代码这样，Dispatch Queue的名称推荐使用应用程序ID这种逆序全程域名（FQDN,fully qualified domain name）。该名称在Xcode 和 Instruments的调试器中作为Dispatch Queue 名称表示。另外，该名称也出现在应用程序崩溃时所生成的CrashLog中。我们命名时应遵循这样的原则：对我们编程人员来说简单易懂，对用户来说也要易懂。如果嫌命名麻烦设为 NULL也可以，但你在调试中一定会后悔没有为Dispatch Queue 署名。
生成 Serial Dispatch Queue 时，像该源代码这样，将第二个参数指定为NULL。生成 Concurrent Dispatch Queue 时，像下面源代码一样，指定为DISPATCH_QUEUE_CONCURRENT。

dispatch_queue_t myConcurrentDispatchQueue = dispatch_queue_create("com.example.gcd.MyConcurrentDispatchQueue", DISPATCH_QUEUE_CONCURRENT);

dispatch_queue_create 函数的返回值为表示 Dispatch Queue 的“dispatch_queue_t类型”。在之前源代码中所出现的变量queue均为dispatch_queue_t类型变量。

dispatch_queue_t myConcurrentDispatchQueue = dispatch_queue_create("com.example.gcd.MyConcurrentDispatchQueue", DISPATCH_QUEUE_CONCURRENT);
dispatch_async(myConcurrentDispatchQueue, ^
	NSLog(@"block on myConcurrentDispatchQueue");
);

该源代码在Concurrent Dispatch Queue 中执行指定的Block。
另外，遗憾的是尽管有 ARC 这一通过编译器自动管理内存的优秀技术，但生成的Dispatch Queue 必须由程序员负责释放。这是因为Dispatch Queue 并没有像Block那样具有作为 Objective-C 对象来处理的技术。
通过dispatch_queue_create 函数生成的 Dispatch Queue 在使用结束后通过 dispatch_release 函数释放。
注意：在iOS6.0后 ，GCD对象使用ARC 的管理，ARC程序中不再需要调用dispatch_release来释放GCD对象

dispatch_release(mySerialDispatchQueue);

该名称中含有release，由此可以推测出相应地也存在 dispatch_retain 函数。

dispatch_retain(myConcurrentDispatchQueue);

即Dispatch Queue 也像Objective-C的引用计数式内存管理一样，需要通过dispatch_retain 函数和dispatch_release函数的引用计数来管理内存。前面的源代码中，需要释放通过 dispatch_queue_create函数生成并赋值给变量myConcurrentDispatchQueue 中的 Concurrent Dispatch Queue。

dispatch_queue_t myConcurrentDispatchQueue = dispatch_queue_create(com.example.gcd.MyConcurrentDispatchQueue", DISPATCH_QUEUE_CONCURRENT);

dispatch_async(MyConcurrentDispatchQueue, ^
	NSLog(@"block on myConcurrent DispatchQueue");
);

dispatch_release(myConcurrentDispatchQueue);

虽然Concurrent Dispatch Queue是使用多线程执行追加的处理，但像该例这样，在dispatch_sync函数中追加Block到Concurrent Dispatch Queue，并立即通过dispatch_release 函数进行释放是否可以呢?
源代码完全没有问题。在dispatch_async函数中追加Block到Dispatch Queue，换言之，该 Block 通过 dispatch_retain 函数持有 Dispatch Queue。无论 Dispatch Queue 是 Serial Dispatch Queue还是Concurrent Dispatch Queue都一样。一旦Block 执行结束，就通过 dispatch_release 函数释放该 Block 持有的 Dispatch Queue。
也就是说，在dispatch_async 函数中追加 Block 到 Dispatch Queue 后，即使立即释放 Dispatch Queue，该 Dispatch Queue 由于被 Block 所持有也不会被废弃，因而Block 能够执行。Block 执行结束后会释放Dispatch Queue，这时谁都不持有Dispatch Queue，因此它会被废弃。
另外，能够使用dispatch_retain 函数和 dispatch_release 函数的地方不仅是在 Dispatch Queue中。在之后介绍的几个GCD的API中，名称中含有“create”的 API 在不需要其生成的对象时，有必要通过dispatch_release 函数进行释放。在通过函数或方法获取 Dispatch Queue 以及其他名称中含有create 的 API 生成的对象时，有必要通过dispatch_retain 函数持有，并在不需要时通过 dispatch_release 函数释放。

（三）Main Dispatch Queue / Global Dispatch Queue

第二种方法是获取系统标准提供的 Dispatch Queue。
实际上不用特意生成Dispatch Queue 系统也会给我们提供几个。那就是Main Dispatch Queue和Global Dispatch Queue。
Main Dispatch Queue 正如其名称中含有的“Main”一样，是在主线程中执行的Dispatch Queue。因为主线程只有1个，所以Main Dispatch Queue 自然就是Serial Dispatch Queue。
追加到Main Dispatch Queue 的处理在主线程的RunLoop 中执行。由于在主线程中执行，因此要将用户界面的界面更新等一些必须在主线程中执行的处理追加到 Main Dispatch Queue 使用。这正好与NSObject类的performSelectorOnMainThread 实例方法这一执行方法相同。

另一个Global Dispatch Qucue 是所有应用程序都能够使用的Concurrent Dispatch Queue。没有必要通过dispatch_queue_create 函数逐个生成Concurrent Dispatch Queue。只要获取 Global Dispatch Queue 使用即可。
另外，Global Dispatch Queue 有4个执行优先级，分别是高优先级（High Priority）、默认优先级（Default Priority）、低优先级（Low Priority）和后台优先级（Background Priority）。通过 XNU内核管理的用于Global Dispatch Queue 的线程，将各自使用的Global Dispatch Queue 的执行优先级作为线程的执行优先级使用。在向Global Dispatch Queue 追加处理时，应选择与处理内容对应的执行优先级的 Global Dispatch Queue。
但是通过XNU内核用于GlobalDispatch Queue的线程并不能保证实时性，因此执行优先级只是大致的判断。例如在处理内容的执行可有可无时，使用后台优先级的Global Dispatch Queue等，只能进行这种程度的区分。
系统提供的 Dispatch Queue 。

名称	Dispatch Queue的种类	说明
Main Dispatch Queue	Serial 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的获取方法如下

/*
 * Main Dispatch Queue的获取方法
 */
dispatch_queue_t mainDispatchQueue = dispatch_get_main_queue();
/*
 *Global Dispatch Queue(高优先级)的获取方法
 */
dispatch_queue_t globalDispatchQueueHigh = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, O);
/*
 * Global Dispatch Queue(默认优先级)的获取方法
 */
dispatch_queue_t globalDispatchQueueDefault = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, O);
/*
 *Global Dispatch Queue(低优先级)的获取方法
 */
dispatch_queue_t globalDispatchQueueLow = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_LOW, O);
/*
 * Global Dispatch Queue(后台优先级)的获取方法
 */
dispatch_queue_t globalDispatchQueueBackground = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_BACKGROUND, O);

另外，对于Main Dispatch Queue 和 Global Dispatch Queue 执行 dispatch_retain 函数和 dispatch_release 函数不会引起任何变化，也不会有任何问题。这也是获取并使用Global Dispatch Queue 比生成、使用、释放 Concurrent Dispatch Queue 更轻松的原因。
当然，源代码上在进行类似通过dispatch_queue_create 函数生成Dispatch Queue 的处理要更轻松时，可参照引用计数式内存管理的思考方式，直接在Main Dispatch Queue 和 Global Dispatch Queue 中执行 dispatch_retain 函数和 dispatch_release 函数。
以下列举使用了Main Dispatch Queue 和 Global Dispatch Queue 的源代码:

/*
 *在默认优先级的Global Dispatch Queue中执行Block
 */
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, O), ^
	/*
	 * 可并行执行的处理
	 */
	/*
	 * 在Main Dispatch Queue中执行Block
	 */
	dispatch_async(dispatch_get_main_queue(), ^
		/*
	 	 * 只能在主线程中执行的处理
	 	 */
	);
) ;

（四）dispatch_set_target_queue

dispatch_queue_create 函数生成的 Dispatch Queue 不管是Serial Dispatch Queue 还是 Concurrent Dispatch Queue，都使用与默认优先级Global Dispatch Queue 相同执行优先级的线程。而变更生成的Dispatch Queue 的执行优先级要使用dispatch_set_target_queue 函数。在后台执行动作处理的 Serial Dispatch Queue 的生成方法如下:

dispatch_queue_t mySerialDispatchQueue = dispatch_queue_create("com.example.gcd.MySerialDispatchQueue",NULL);
dispatch_queue_t globalDispatchQueueBackground = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_BACKGROUND, O);
dispatch_set_target_queue(mySerialDispatchQueue, globalDispatchQueueBackground);

指定要变更执行优先级的Dispatch Queue为dispatch_set_target_queue 函数的第一个参数，指定与要使用的执行优先级相同优先级的Global Dispatch Queue为第二个参数（目标）。第一个参数如果指定系统提供的Main Dispatch Queue 和 Global Dispatch Queue 则不知道会出现什么状况，因此这些均不可指定。
将Dispatch Queue 指定为dispatch_set_target_queue 函数的参数，不仅可以变更 Dispatch Queue的执行优先级，还可以作成Dispatch Queue的执行阶层。如果在多个Serial Dispatch Queue 中用 dispatch_set_target_queue 函数指定目标为某一个Serial Dispatch Queue，那么原先本应并行执行的多个Serial Dispatch Queue，在目标Serial Dispatch Queue 上只能同时执行一个处理。

在必须将不可并行执行的处理追加到多个 Serial Dispatch Queue 中时，如果使用dispatch_set_target_queue 函数将目标指定为某一个 Serial Dispatch Queue，即可防止处理并行执行。

（五）dispatch_after

经常会有这样的情况:想在3秒后执行处理。可能不仅限于3秒，总之，这种想在指定时间后执行处理的情况，可使用dispatch_after 函数来实现。
在3秒后将指定的Block追加到Main Dispatch Queue 中的源代码如下:

dispatch_time_t time = dispatch_time(DISPATCH_TIME_NOW, 3u11 * NSEC_PER_SEC);

dispatch_after(time, dispatch_get_main_queue(), ^
	NSLog(@"waited at least three seconds.");
);

需要注意的是，dispatch_after函数并不是在指定时间后执行处理，而只是在指定时间追加处理到Dispatch Queue。此源代码与在3秒后用dispatch_async 函数追加Block到Main Dispatct Queue 的相同。
因为Main Dispatch Queue 在主线程的RunLoop中执行，所以在比如每隔1/60秒执行的 RunLoop中，Block最快在3秒后执行，最慢在3秒+1/60秒后执行，并且在Main Dispatch Queue有大量处理追加或主线程的处理本身有延迟时，这个时间会更长。
虽然在有严格时间的要求下使用时会出现问题，但在想大致延迟执行处理时，该函数是非常有效的。
另外，第二个参数指定要追加处理的Dispatch Queue，第三个参数指定记述要执行处理的 Block。
第一个参数是指定时间用的dispatch_time_t类型的值。该值使用dispatch_time 函数或 dispatch_walltime 函数作成。
dispatch_time函数能够获取从第一个参数dispatch_time_t类型值中指定的时间开始，到第二个参数指定的毫微秒单位时间后的时间。第一个参数经常使用的值是之前源代码中出现的 DISPATCH_TIME_NOW。这表示现在的时间。即以下源代码可得到表示从现在开始1秒后的 dispatch_time_t类型的值。

dispatch_time_t time = dispatch_time(DISPATCH TIME_NOW, 1ull* NSEC_PER_SEC)

数值和NSEC_PER_SEC的乘积得到单位为毫微秒的数值。“ull”是C语言的数值字面量，是显式表明类型时使用的字符串(表示“unsigned long long”)。如果使用NSEC_PER_MSEC 可以以毫秒为单位计算。以下源代码获取表示从现在开始150毫秒后时间的值。

dispatch_time_t time = dispatch_time(DISPATCH_TIME_NOW, 150U11 * NSEC_PER_MSEC);

dispatch_walltime 函数由POSIX中使用的struct timcspec类型的时间得到dispatch_time_t类型的值。dispatch_time 函数通常用于计算相对时间，而dispatch_walltime 函数用于计算绝对时间。例如在dispatch_after函数中想指定 2111年11月 11日 11 时 11 分 11 秒这一绝对时间的情况，这可作为粗略的闹钟功能使用。
struct timespec 类型的时间可以很轻松地通过NSDate类对象作成。

dispatch_time_t getDispatchTimeByDate(NSDate *date) 
	NSTimeInterval interval;
	double second, subsecond;
	struct timespec time;
	dispatch_time_t milestone;
	interval =[date timeIntervalsince1970];
	subsecond = modf(interval, &second);
	time.tv_sec = second;
	time.tv_nsec = subsecond * NSEC_PER_SEC;
	milestone = dispatch_walltime(&time, 0);
	return milestone;

上面源代码可由NSDate类对象获取能传递给dispatch_after函数的dispatch_time_t类型的值。

（六）Dispatch Group

在追加到 Dispatch Queue 中的多个处理全部结束后想执行结束处理，这种情况会经常出现。使用一个Serial Dispatch Queue 时，只要将想执行的处理全部追加到该 Serial Dispatch Queue中并在最后追加结束处理，即可实现。但是在使用Concurrent Dispatch Queue 时或同时使用多个 Dispatch Qucue 时，源代码就会变得颇为复杂。
在此种情况下使用Dispatch Group。例如下面源代码为：追加3个Block到 Global Dispatch Queue，这些Block如果全部执行完毕，就会执行Main Dispatch Queue 中结束处理用的 Block。

dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, O);
dispatch_group_t group = dispatch_group_create();
dispatch_group_async(group, queue, ^
	NSLog(@"blk0");
);
dispatch_group_async(group, queue, ^
	NSLog(@"blk1");
);
dispatch_group_async(group, queue, ^
	NSLog(@"blk2");
);
dispatch_group_notify(group, dispatch_get_main_queue(), ^
	NSLog(@"done");
);
dispatch_release(group);

该源代码的执行结果如下：

blk1
blk2
blk0
done

因为向Global Dispatch Queue 即 Concurrent Dispatch Queue 追加处理，多个线程并行执，所以追加处理的执行顺序不定。执行时会发生变化，但是此执行结果的done 一定是最后输出的。
无论向什么样的Dispatch Queue 中追加处理，使用Dispatch Group都可监视这些处理执行的结束。一旦检测到所有处理执行结束，就可将结束的处理追加到Dispatch Queue 中。这就是使用 Dispatch Group 的原因。
先dispatch_group_create 函数生成dispatch_group_t类型的Dispatch Group。如 dispatch_group_create 函数名中所含的create 所示，该 Dispatch Group与Dispatch Queue 相同，在使用结束后需要通过dispatch_release 函数释放。
dispatch_group_async 函数 与 dispatch_async 函数相同，都追加 Block 到指定的 Dispatch Queue 中。与 dispatch_async 函数不同的是指定生成的 Dispatch Group 为第一个参数。指定的 Block 属于指定的 Dispatch Group。
另外，与追加Block 到 Dispatch Queue 时同样，Block 通过 dispatch_retain 函数持有Dispatch Group，从而使得该Block属于Dispatch Group。这样如果Block执行结束，该Block就通过 dispatch_release 函数释放持有的 Dispatch Group。一旦 Dispatch Group 使用结束，不用考虑属于该 Dispatch Group 的 Block，立即通过 dispatch_release 函数释放即可。
在追加到 Dispatch Group 中的处理全部执行结束时，该源代码中使用的 dispatch_group_notify函数会将执行的 Block 追加到 Dispatch Queue 中，将第一个参数指定为要监视的 Dispatch Group。在追加到该 Dispatch Group 的全部处理执行结束时，将第三个参数的 Block 追加到第二个参数 Dispatch Queue 中。在dispatch_group_notify 函数中不管指定什么样的Dispatch Queue，属于 Dispatch Group 的全部处理在追加指定的Block 时都已执行结束。
另外，在Dispatch Group 中也可以使用dispatch_group_wait 函数仅等待全部处理执行结束。

dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, O);
dispatch_group_t group = dispatch_group_create();
dispatch_group_async(group, queue, ^
	NSLog(@"blk0");
);
dispatch_group_async(group, queue, ^
	NSLog(@"blkl");
);
dispatch_group_async(group, queue, ^
	NSLog(@"blk2");
);
dispatch_group_wait(group, DISPATCH_TIME_FOREVER); dispatch_release(group);

dispatch_group_wait 函数的第二个参数指定为等待的时间（超时）。它属于 dispatch_time_t类型的值。该源代码使用DISPATCH_TIME_FOREVER，意味着永久等待。只要属于Dispatch Group的处理尚未执行结束，就会一直等待，中途不能取消。
如同dispatch_after 函数说明中出现的那样，指定等待间隔为1秒时应做如下处理。

dispatch_time_t time = dispatch_time(DISPATCH_TIME_NOW, 1U11 * NSEC_PER_SEC);
long result * dispatch_group_wait(group, time);
if (result == 0) 
	/*属于Dispatch Group的全部处理执行结束*/
 else 
	/*
	 *属于Dispatch Group的某一个处理还在执行中
	 */

如果dispatch_group_wait 函数的返回值不为0，就意味着虽然经过了指定的时间，但属于 Dispatch Group的某一个处理还在执行中。如果返回值为0，那么全部处理执行结束。当等待时间为DISPATCH TIME FOREVER、由dispatch_group_wait函数返回时，由于属于Dispatch Group的处理必定全部执行结束，因此返回值恒为0。
这里的“等待”是什么意思呢？这意味着一旦调用dispatch_group_wait 函数，该函数就处于调用的状态而不返回。即执行dispatch_group_wait函数的现在的线程（当前线程）停止。在经过 dispatch_group_wait 函数中指定的时间或属于指定Dispatch Group的处理全部执行结束之前，执行该函数的线程停止。
指定DISPATCH_TIME_NOW，则不用任何等待即可判定属于Dispatch Group的处理是否执行结束。

long result = dispatch_group_wait(group, DISPATCH_TIME_NOW);

在主线程的RunLoop的每次循环中，可检查执行是否结束，从而不耗费多余的等待时间，虽然这样也可以，但一般在这种情形下，还是推荐用dispatch_group_notify函数追加结束处理到 Main Dispatch Queue 中。这是因为dispatch_group_notify 函数可以简化源代码。

（七）dispatch_barrier_async

在访问数据库或文件时，如前所述，使用 Serial Dispatch Queue 可避免数据竞争的问题。
写入处理确实不可与其他的写入处理以及包含读取处理的其他某些处理并行执行。但是如果读取处理只是与读取处理并行执行，那么多个并行执行就不会发生问题。
也就是说，为了高效率地进行访问，读取处理追加到Concurrent Dispatch Queue中，写入处理在任一个读取处理没有执行的状态下，追加到Serial Dispatch Queue中即可（在写入处理结束之前，读取处理不可执行）。
虽然利用Dispatch Group 和dispatch_set_target_queue 函数也可实现，但是源代码会很复杂 GCD为我们提供了更为聪明的解决方法-dispatch_barrier_async 函数。该函数同 dispatch_queue_create 函数生成的Concurrent_Dispatch_Queue 一起使用。
首先dispatch_queue_create 函数生成Concurrent_Dispatch_Queue，在dispatch_async 中追加读取处理。

dispatch_queue_t queue = dispatch_queue_create("com.example.gcd.ForBarrier", DISPATCH_QUEUE_CONCURRENT);

dispatch_async(queue, blk0_for_reading);
dispatch_async(queue, blkl_for_reading);
dispatch_async(queue, blk2_for_reading);
dispatch_async(queue, blk3_for_reading);
dispatch_async(queue, blk4_for_reading);
dispatch_async(queue, blk5_for_reading)	
dispatch_async(queue, blk6_for_reading);
dispatch_async(queue, blk7_for_reading);

dispatch_release(queue);

在 blk3_for_reading 处理和blk4_for_