前言：
很早之前就想总结一下多线程这块，在工作中经常用到，尤其是现在开发的一款跟图片处理相关的应用，多线程的重要性就更加突出。
这篇文章打算总结一些 GCD 的一些概念和在开发中一些常用方法。

什么是 GCD

在iOS应用程序中，如果不做特殊的操作，程序的代码都是跑在主线程中的。
在主线程中有一个 RunLoop，iOS 会在 RunLoop 循环的间隙来执行 UI 的刷新，如果我们在主线程中执行耗时较长的代码，UI 刷新不及时，在用户看来就是我们的应用卡住了。
为了避免这种情况的发生，我们必须把耗时任务（比如 IO 操作，网络请求）放在其他线程中执行以保证程序的流畅。
幸运的是，Apple 提供了非常强大的线程库，使得 iOS 的多线程开发变得十分简单(相对于直接使用线程)。
这个库就叫做 GCD (Grand Central Dispatch)，提供了C语言接口的并发编程模型。

那么他的优势都是有哪些呢，下面列出一些：

• GCD 是苹果公司为多核的并行运算提出的解决方案
• GCD 会自动利用更多的 CPU 内核（比如双核、四核）
• GCD 会自动管理线程的生命周期（创建线程、调度任务、销毁 线程）
• 程序员只需要告诉 GCD 想要执行什么任务，不需要编写任何线程管理代码

GCD 的一些概念

首先明确一下任务和队列的概念，下面稍微介绍一下
GCD 的执行任务方式有同步方式和异步方式：
* 同步：只能在当前线程中执行任务，不具备开启新线程的能力
* 异步：可以在新的线程中执行任务，具备开启新线程的能力

GCD的队列可以分为2大类型 并发队列和串行队列：
* 并发队列（Concurrent Dispatch Queue）
* 可以让多个任务并发（同时）执行（自动开启多个线程同时执行任务）
* 并发功能只有在异步（dispatch_async）函数下才有效

* 串行队列（Serial Dispatch Queue）
* 让任务一个接着一个地执行（一个任务执行完毕后，再执行下一个任务

感觉这四个概念比较容易混淆，下面列出来总结一下

同步和异步主要影响：能不能开启新的线程
同步：只是在当前线程中执行任务，不具备开启新线程的能力
异步：可以在新的线程中执行任务，具备开启新线程的能力

并发和串行主要影响：任务的执行方式
并发：允许多个任务并发（同时）执行
串行：一个任务执行完毕后，再执行下一个任务

GCD 的一些用法

简单起见，逐个直接列出来吧。前面几条是常见的线程操作函数，后面几条也是经常用到的 GCD 的用法。

（1）并发队列

GCD 默认已经提供了全局的并发队列，供整个应用使用，可以无需手动创建。
只需将自己的耗时操作放进这个 block 块中，GCD 就会自动给我们开启子线程来完成操作。开启的子线程数量视情况而定。

dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        // ...
});

注意：上面函数的参一是全局并发队列的优先级

#define DISPATCH_QUEUE_PRIORITY_HIGH 2 // 高
#define DISPATCH_QUEUE_PRIORITY_DEFAULT 0 // 默认（中）
#define DISPATCH_QUEUE_PRIORITY_LOW (-2) // 低
#define DISPATCH_QUEUE_PRIORITY_BACKGROUND INT16_MIN // 后台

（2）串行队列

最常见的串行队列就是主队列 main queue ，他是一个特殊的串行队列。
注意：放在主队列中的任务，都会自动放到主线程中执行。
我们的一些 UI 操作比如 reload data 等就需要在主线程中完成，将这些操作放到主队列，GCD 会自动将他们依次放进主线程执行任务。

dispatch_async(dispatch_get_main_queue(), ^{
       // ...
});

当然，我们也可以手动创建串行队列

// 创建串行队列（队列类型传递NULL或者DISPATCH_QUEUE_SERIAL）
// 创建并发队列 传 DISPATCH_QUEUE_CONCURRENT
dispatch_queue_t queue = dispatch_queue_create("com.zk.testqueue", NULL);
dispatch_async(queue, ^{
});

（3）线程间通信

用到最多的莫过于子线程完成耗时任务后回到主线程执行 UI 操作。

dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        // 子线程 耗时操作
        dispatch_async(dispatch_get_main_queue(), ^{
            // 主线程 UI 操作
        });
});

（4）队列组 group

dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    
// 创建 GCD 组
dispatch_group_t group = dispatch_group_create();
    
// 将任务分别添加到队列组
dispatch_group_async(group, queue, ^{
    NSLog(@"task_1 ==== %@", [NSThread currentThread]);
});
dispatch_group_async(group, queue, ^{
    NSLog(@"task_2 ==== %@", [NSThread currentThread]);
});
dispatch_group_async(group, queue, ^{
    NSLog(@"task_3 ==== %@", [NSThread currentThread]); 
});
    
// 当队列组中所有的任务都执行完毕之后，会进入这个方法
dispatch_group_notify(group, queue, ^{
    NSLog(@"dispatch_group_notify");
});

（5）延时执行 after

// 可以任意指定延迟后执行函数的线程
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        // 延迟执行函数
});

当然，也可以用其他方法完成同样需求

[self performSelector:@selector(test) withObject:nil afterDelay:2];

 [NSTimer scheduledTimerWithTimeInterval:2 repeats:false block:^(NSTimer * _Nonnull timer) {
       // ...
}];

（6）一次执行 once

在应用的整个运行期间只会创建一次。慎用。
最常见的应用场景就是单例的简单创建

+ (instancetype)defaultManager
{
    static USLocationManager *manager;
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        manager = [[USLocationManager alloc] init];
    });
    return manager;
}

（7）栅栏函数 barrier

由于在并发队列中的任务的执行时无序的，所以当遇到需要某个任务与其他任务的顺序有要求的时候，这时栅栏函数就派上用场了。
注意两点：

• 栅栏函数不能用全局并发队列哦，只能是自己手动创建的全局并发队列才有效果。
• 栅栏函数之前的任务的执行是无序的。
  上代码

// 注意：栅栏函数不能用全局并发队列，会无效
    //dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    
    dispatch_queue_t queue = dispatch_queue_create("com.zk.barrier", DISPATCH_QUEUE_CONCURRENT);
    
    dispatch_async(queue, ^{
        NSLog(@"task_1 === %@", [NSThread currentThread]);
    });
    
    dispatch_async(queue, ^{
        NSLog(@"task_2 === %@", [NSThread currentThread]);
    });
    
    dispatch_async(queue, ^{
        NSLog(@"task_3 === %@", [NSThread currentThread]);
    });
    
    dispatch_barrier_async(queue, ^{
        NSLog(@" ====================== barrier task ==================");
    });
    
    dispatch_async(queue, ^{
        NSLog(@"task_4 === %@", [NSThread currentThread]);
    });

输出：

2017-02-25 17:56:52.299 ZKGCD[6922:1084089] task_1 === <NSThread: 0x60800027c100>{number = 4, name = (null)}
2017-02-25 17:56:52.299 ZKGCD[6922:1084092] task_2 === <NSThread: 0x600000077b80>{number = 3, name = (null)}
2017-02-25 17:56:52.299 ZKGCD[6922:1084088] task_3 === <NSThread: 0x608000460580>{number = 5, name = (null)}
2017-02-25 17:56:52.299 ZKGCD[6922:1084088]  ====================== barrier task ==================
2017-02-25 17:56:52.299 ZKGCD[6922:1084088] task_4 === <NSThread: 0x608000460580>{number = 5, name = (null)}

（8）快速迭代循环 apply

类似 for 循环，区别就是 apply 函数执行速度更快。因为会默认开启多条线程来完成任务（主线程也会参与），所以脚标 index 是不准确的。

// 参1：遍历次数
// 参2：并发队列（注意：只能是并发队列）
// 参3：相当于 index，但是是无序的
dispatch_apply(100, dispatch_get_global_queue(0, 0), ^(size_t index) {
        
});

（9）dispatch_async与dispatch_sync区别

//串行队列            
dispatch_queue_t _serialQueue = dispatch_queue_create("com.zk.test", DISPATCH_QUEUE_SERIAL);            
dispatch_async(_serialQueue, ^{ NSLog(@"1");});            
NSLog(@"2");            
dispatch_async(_serialQueue, ^{ NSLog(@"3");});            
NSLog(@"4");            
     
dispatch_sync(_serialQueue, ^{ NSLog(@"1");});            
NSLog(@"2");            
dispatch_sync(_serialQueue, ^{ NSLog(@"3");});            
NSLog(@"4");

对于dispatch_async来说，把 block 提交到队列，立刻返回执行下一步。不等待 block 执行完毕。所以它的打印结果有很多中，譬如说 2413 或者 2143 或者 1234，但是 1 总在 3 前面。因为提交到的队列是串行队列。（并发队列顺序就不一定了）

对于dispatch_sync来说，把 block 提交到队列，不立刻返回。在当前线程中等待提交到队列的 block 执行完毕才继续向下执行。所以其执行结果只有一种: 1234。无论你运行多少次都会是这一种结果。

总结来说，dispatch_async 是异步操作，不管队列是串行还是并发队列，这个 async 函数都是立即返回，接着程序就会直接往下走，不会等待 Block 中的操作。
而 dispatch_sync 是同步操作，会在当前线程中等待 Block 中的所有操作都完成之后，函数才会返回，也就是说阻塞了线程。
那么，从而衍生了一个有意思的问题，就是死锁。看下一个条目

（10）dispatch_sync引发的死锁

发生死锁

有了上一条知识点的铺垫，我们就能很好理解 GCD 引发的死锁。看下面这段代码

- (void)viewDidLoad {
    [super viewDidLoad];
    NSLog(@"==>1");
    dispatch_sync(dispatch_get_main_queue(), ^{
        NSLog(@"==>2");
    });
    NSLog(@"==>3");
}

之所以发生了死锁，原因如下：
当前 dispatch_sync() 函数在主线程中调用。
调用 dispatch_sync() 函数会立即阻塞调用时该函数所在的线程，即主线程。等待 dispatch_sync() 函数返回。
dispatch_sync() 函数追加任务（即 Block 代码块）到主队列 dispatch_get_main_queue() 这个串行队列中。
主队列的任务在主线程中执行，但此时主线程被阻塞，无法执行Block代码块，导致 dispatch_sync() 函数无法返回，一直等待Block被主线程执行。最终导致死锁。sync 等待 mainThread 执行完成， mianThread 等待 sync 函数返回。

下面这个例子可以跟上面对比一下

- (void)viewDidLoad {
    [super viewDidLoad];
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
    NSLog(@"==>1");
    dispatch_sync(dispatch_get_main_queue(), ^{
        NSLog(@"==>2");
    });
    NSLog(@"==>3");
});
}

async 立即返回，viewDidLoad 执行完毕，即主线程执行完毕。
同时，全局并发队列立即执行异步 block ，打印 1，当执行到 sync 它会等待 block 执行完成才返回。而此时 main_queue 中的任务已经完毕（如果主线程操作比较多这个串行队列会多走一会儿），直接执行了 Block 中的内容，从而 sync 函数成功返回。程序继续往下走没有问题。（打印1，2，3）但是如果对代码进行稍微修改。想想会发生什么：

- (void)viewDidLoad {
    [super viewDidLoad];
    
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        NSLog(@"==>1");
        dispatch_sync(dispatch_get_main_queue(), ^{
            NSLog(@"==>2");
        });
        NSLog(@"==>3");
    });
    while (1) {
    }
}

不难看出，main_queue 中的 block 代码会一直等着主线程操作完成才能执行。而 sync 一直等着 block 的执行完成。恰巧此时的主线程陷入无限循环中难以自拔，所以程序仅仅打印了 1，然后就陷入了僵持中。