概述
Execute code concurrently on multicore hardware by submitting work to dispatch queues managed by the system.
Grand Central Dispatch (GCD) comprises language features, runtime libraries, and system enhancements that provide systemic, comprehensive improvements to the support for concurrent code execution on multicore hardware in macOS, iOS, watchOS, and tvOS.
The BSD subsystem, Core Foundation, and Cocoa APIs have all been extended to use these enhancements to help both the system and your application to run faster, more efficiently, and with improved responsiveness. Consider how difficult it is for a single application to use multiple cores effectively, let alone doing it on different computers with different numbers of computing cores or in an environment with multiple applications competing for those cores. GCD, operating at the system level, can better accommodate the needs of all running applications, matching them to the available system resources in a balanced fashion.
串行和并行队列（dispatch queue）
GCD provides and manages FIFO queues to which your application can submit tasks in the form of block objects. Work submitted to dispatch queues are executed on a pool of threads fully managed by the system. No guarantee is made as to the thread on which a task executes.
Serial and Concurrent Queues
A dispatch queue can be either serial, so that work items are executed one at a time, or it can be concurrent, so that work items are dequeued in order, but run all at once and can finish in any order. Both serial and concurrent queues process work items in first in, first-out (FIFO) order.
System-Provided Queues
When an app launches, the system automatically creates a special queue called the main queue. Work items enqueued to the main queue execute serially on your app’s main thread. You can access the main queue using the main type property.
Attempting to synchronously execute a work item on the main queue results in dead-lock.
In addition to the serial main queue, the system also creates a number of global concurrent dispatch queues. You can access the global concurrent queue that best matches a specified quality of service (QoS) using the global(attributes:) type method.
串行队列（serial）
串行队列会等待上一个任务执行完成，才去开始执行下一个任务
并行队列（concurrent）
并行队列会不需要等待上一个任务执行完成，而是所有的任务可以同时开始执行
同步和异步任务（Synchronous and Asynchronous Execution）
Each work item can be executed either synchronously or asynchronously. When a work item is executed synchronously with the sync method, the program waits until execution finishes before the method call returns. When a work item is executed asynchronously with the async method, the method call returns immediately.
同步任务（sync）
执行sync函数以block的形式添加一个任务到队列当中，并阻塞当前线
程，等到block任务中的执行完成sync函数才会返回（return）
异步任务（async）
执行async函数以block的形式添加一个任务到队列当中，async函数直接返回（return）
死锁（dead-lock）
串行队列的同步任务中，添加同步任务到当前队列（同一个串行队列）中就会产生死锁
dispatch_sync(serialQueue, ^{
NSLog(@"任务1开始");
dispatch_sync(serialQueue, ^{
NSLog(@"任务2开始");
});
NSLog(@"任务1结束");
});
分析：
1、执行最外层dispatch_sync函数添加任务1到串行队列（serialQueue）中，等待这个dispatch_sync函数返回（return）
2、开始执行队列中的任务1
3、打印“任务1开始”
4、执行任务1中的dispatch_sync函数添加任务2到串行队列（serialQueue）中，等待这个dispatch_sync函数返回（return）
5、此时，添加任务1的dispatch_sync函数要返回（return），就必须等待添加任务2的dispatch_sync函数要返回（return），此时“任务1等待任务2完成”；而任务1和任务2都被添加到了同一个串行队列（serialQueue）中，而串行队列要执行下一个任务，必须等待上一个任务完成，而任务1先与任务2添加，所以要等待任务2执行，就需要任务1先执行完成，此时就是“任务2等待任务1完成”。如此任务1和任务2相互等待，就会造成死锁
