iOS学习之——GCD（Grand Central Dispatch）

Grand Central Dispatch（GCD）是异步执行任务的技术之一。一般将应用程序中记述的线程管理用的代码在系统级中实现。开发者只需要定义想要执行的任务并追加到适当的Dispatch Queue中，GCD就能生成必要的线程并计划执行任务。由于线程管理是作为系统的一部分来实现的，因此可统一管理，也可执行任务，这样就比以前的线程更有效率。（摘自苹果的官方说明）

dispatch_async(queue,^{
   /* *长时间处理 *例如AR用画像识别 *例如数据库访问 */
   /* *长时间处理结束，主线程使用该处理结果。 */

   dispatch_async(dispatch_get_main_queue(),^{
     /* *只在主程序可以执行的处理 * *例如用户界面更新 */
   })
} );

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

dispatch_async(queue,^{

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

dispatch_async(dispatch_get_main_queue(),^{

Dispatch Queue:执行处理的等待队列
应用程序编程人员通过dispatch_async函数等API，在Block语法中记述想要执行的处理并将其追加到Dispatch Queue中。Dispatch Queue按照追加的顺序（先进先出FIFO）执行处理。
另外在执行处理时存在两种Dispatch Queue，一种是等待现在执行中处理的Serial Dispatch Queue，另一种是不等待现在执行中处理的Concurrent Dispatch Queue。

Serial Dispatch Queue                  使用一个线程
Concurrent Dispatch Queue              使用多个线程

当变量queue为Concurrent Dispatch Queue时，因为不用等待现在执行中的处理结束，可以并行执行多个处理，但并行执行的处理数量取决于当前系统的状态。即iOS和OS X基于Dispatch Queue的处理数、CPU核数以及CPU负荷等当前系统的状态来决定Concurrent Dispatch Queue中并行执行的处理数。所谓”并行执行”，就是使用多个线程同时执行多个处理。
iOS和OS X的核心——XNU内核觉得应当使用的线程数，并只生成所需的线程执行处理。另外，当处理结束，应当执行的处理数减少时，XNU内核会结束不再需要的线程。XNU内核仅适用Concurrent Dispatch Queue便可完美地管理并行执行多个处理的线程。
虽然知道了有Concurrent Dispatch Queue和Serial Dispatch Queue这两种，但如何才能得到这些Dispatch Queue呢？方法有两种：
一、通过GCD 的API生成Dispatch Queue。
通过dispatch_queue_create 函数可生成Dispatch Queue。以下源代码生成了Serial Dispatch Queue。

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

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中同时只能执行1个追加处理，但如果将处理分别追加到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的生成个数应当仅限所必需的数量。
当想并行执行不发生数据竞争等问题的处理时，使用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中。
生成Serial Dispatch Queue时，像上面源代码这样，将第二个参数指定为NULL。生成Concurrent Dispatch Queue时，像下面源代码一样，指定为DISPATCH_QUEUE_CONCURRENT.

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

dispatch_queue_create函数的返回值为表示Dispatch Queue的“dispatch_queue_t类型”。

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

该源代码在你Concurrent Dispatch Queue中执行指定的Block。
注意：生成的Dispatch Queue必须由程序员负责释放。

dispatch_release(mySerialDispatchQueue);

相应地有dispatch_retain函数：

dispatch_retain(myConcurrentDispatchQueue);

即Dispatch Queue也想OC的引用计数式内存管理一样，需要通过dispatch_retain函数和dispatch_release函数的引用计数来管理内存。

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

  dispatch_async(myConcurrentDispatchQueue, ^{NSLog(@"block on myConcurrentDispatchQueue");});

  dispatch_release(myConcurrentDispatchQueue);

在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_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。（Main Dispatch Queue和Global Dispatch Queue）
Main Dispatch Queue：在主程序中执行的Dispatch Queue。因为主线程只有1个，所以Main Dispatch Queue自然就是Serial Dispatch Queue。
追加到Main Dispatch Queue的处理在主线程的RunLoop中执行。由于在主线程中执行，因此要将用户界面的界面更新等一些必须在主线程中执行的处理追加到Main Dispatch Queue使用。这正好与NSObject类的performSelectorOnMainThread实例方法这一执行方法相同。
另一个Global Dispatch Queue是所有应用程序都能够使用的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内核用于Global Dispatch Queue的线程并不能保证实时性，因此执行优先级只是大致的判断。例如在处理内容的执行可有可无时，使用后台优先级的Global 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_PRIOROTY_HIGH,0);

//Global Dispatch Queue(默认优先级)的获取方法
dispatch_queue_t globalDispatchQueueDefault = dispatch_get_global_queue(DISPATCH_QUEUE_PRIOROTY_DEFAULT,0);

//Global Dispatch Queue(低优先级)的获取方法
dispatch_queue_t globalDispatchQueueLow = dispatch_get_global_queue(DISPATCH_QUEUE_PRIOROTY_LOW,0);

//Global Dispatch Queue(后台优先级)的获取方法
dispatch_queue_t globalDispatchQueueBackground = dispatch_get_global_queue(DISPATCH_QUEUE_PRIOROTY_BACKGROUND,0);

另外，对于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_PRIOROTY_DEFAULT,0),^{
//可并行执行的处理
//在Main Dispatch Queue中执行Block
dispatch_async(dispatch_get_main_queue(), ^{
  //只能在主线程中执行的处理 
   })；
})

GCD的一些常用方法：

• dispatch_set_target_queue
• dispatch_after
• Dispatch Group
• dispatch_barrier_async
• dispatch_sync
• dispatch_apply
• dispatch_suspend/dispatch_resume
• Dispatch Semaphore
• dispatch_once
• Dispatch I/O