iOS多线程全面解读(二)：GCD

2017 年 12 月 3 日 CocoaChina indulge_in

写在前面

GCD（Grand Central Dispatch）是iOS4引入的强大的线程处理技术，它是基于XNU内核开发的，性能极为优越。

GCD是最受欢迎的多线程处理框架，多数情况我们都可以使用它来进行并行编程，而且基本不用关心线程的管理问题。当然，也有很多情况使用C的API不是那么方便和易于理解（或者说不符合面向对象思想），这时候就是NSOperation发挥作用的时候了（后一篇会讲）。

学习编程不是说那谁谁会多少API，这本身没有什么意义。学习GCD我将重点分析它是如何发生的，本质的原理，而不是故作玄虚的使用GCD所谓的“高级用法”和谈论所谓的“底层实现”，最终目的只是为了让各位真正的理解GCD的精髓??。

一、队列&任务

任务：任务就是一段代码，我们可以直观的想象成GCD里面的block。

同步任务（sync）：同步任务会在当前线程执行，我们通常在编写UI相关的代码的时候，都是在主线程同步执行的。
异步任务（async）：异步任务就是会在当前线程之外的线程执行，当然是不是每一个异步任务都需要开辟新线程由GCD判断。

队列：GCD提供队列（dispatch queue）来管理任务，队列本身是线程安全的，通过FIFO（first in first out）原则来实现对任务的管理，即先加入的任务的先取出来执行。

串行队列：任务将会遵循FIFO原则拿出来依次执行，同一时刻只会有一个任务在执行（就像400米接力赛，只看一个队伍，一个接一个依次跑）。
并行队列：任务同样会遵循FIFO原则拿出来依次执行（这里值得注意），同一时刻有多个任务同时执行（就像100米赛跑，大家同时跑），它们可以理论上说是并行的。

1、创建串行队列

//@param1 队列的标志，一般以倒置的域名+队列的名字命名

//@param2 队列的类型的标志

//创建串行队列

dispatch_queue_t serialQueue = dispatch_queue_create("com.myProject.queue1", DISPATCH_QUEUE_SERIAL);

//获取主队列

dispatch_queue_t mainQueue = dispatch_get_main_queue();

主队列是由系统默认创建的，它管理着我们的主线程和相关的任务（当然可能不止一个主线程），主队列是串行队列。

2、创建并行队列

//创建并行队列

dispatch_queue_t concurrentQueue = dispatch_queue_create("com.myProject.queue2", DISPATCH_QUEUE_CONCURRENT);

//获取全局队列

dispatch_queue_t globalQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

全局队列同样是由系统默认创建的，我们的很多操作都可以利用它来完成，全局队列是并行队列。

3、创建同步任务

dispatch_sync(anyQueue, ^{

//任务代码

});

anyQueue就是上面说到的队列

4、创建异步任务

dispatch_async(anyQueue, ^{

//任务代码

});

anyQueue就是上面说到的队列

二、任务和队列的组合

为了让大家更直观的感受到队列、任务、线程是如何工作的，这里直接放上它们的各种组合用法（分析得比较细，所以篇幅较长，见谅）。

1、串行队列+同步任务

dispatch_queue_t mainQueue = dispatch_get_main_queue();

dispatch_queue_t serialQueue = dispatch_queue_create("com.myProject.queue2", DISPATCH_QUEUE_SERIAL);

NSLog(@"主队列：%@ \n创建的串行队列：%@", mainQueue, serialQueue);

NSLog(@"主线程：%@", [NSThread currentThread]);

NSLog(@"主线程开始");

dispatch_sync(serialQueue, ^{

NSLog(@"任务1执行 %@", [NSThread currentThread]);

[NSThread sleepForTimeInterval:4];

});

dispatch_sync(serialQueue, ^{

NSLog(@"任务2执行 %@", [NSThread currentThread]);

[NSThread sleepForTimeInterval:4];

});

NSLog(@"主线程结束");

我这里写上了主队列只是为了测试用，使用[NSThread sleepForTimeInterval:4];是为了延长任务的执行时间，运行这段代码打印如下：

主队列：<OS_dispatch_queue_main: com.apple.main-thread>

创建的串行队列：<OS_dispatch_queue: com.myProject.queue2>

主线程：<NSThread: 0x60400006f9c0>{number = 1, name = main}

主线程开始

任务1执行 <NSThread: 0x60400006f9c0>{number = 1, name = main}

任务2执行 <NSThread: 0x60400006f9c0>{number = 1, name = main}

主线程结束

打印的结果就很值得研究一下了。

第一点：我们创建了一个串行队列，它确实和我们的主队列不是同一块内存（看打印信息），然而我们在创建的队列中执行任务，同样是用的是主线程（number = 1），这就是同步执行任务。当前线程是主线程，所以就和主线程同步执行（这句话值得多读几遍，思考：如果当前线程是其他线程呢？马上会讲）。

第二点：任务1执行完毕过后任务2才开始执行，任务2执行完毕主线程结束才打印出来，这符合串行队列对任务的处理规则，依次执行。

重点一：更改dispatch_sync执行线程

在上面代码中，两个dispatch_sync函数都是在主线程执行的，所以dispatch_sync中的任务是在主线程执行，这就是同步的真正意义。如果我们让dispatch_sync在另外的线程执行，看看结果是否是我们预料的（dispatch_sync中的任务会在它执行的线程执行）：

dispatch_queue_t mainQueue = dispatch_get_main_queue();

dispatch_queue_t serialQueue = dispatch_queue_create("com.myProject.queue2", DISPATCH_QUEUE_SERIAL);

NSLog(@"主队列：%@ \n创建的串行队列：%@", mainQueue, serialQueue);

NSLog(@"主线程：%@", [NSThread currentThread]);

NSLog(@"主线程开始");

[NSThread detachNewThreadWithBlock:^{

NSLog(@"新开辟的线程：%@", [NSThread currentThread]);



dispatch_sync(serialQueue, ^{

NSLog(@"任务1执行 %@", [NSThread currentThread]);

[NSThread sleepForTimeInterval:4];

});



dispatch_sync(serialQueue, ^{

NSLog(@"任务2执行 %@", [NSThread currentThread]);

[NSThread sleepForTimeInterval:4];

});



}];

NSLog(@"主线程结束");

打印如下：

主队列：<OS_dispatch_queue_main: com.apple.main-thread>

创建的串行队列：<OS_dispatch_queue: com.myProject.queue2>

主线程：<NSThread: 0x604000063300>{number = 1, name = main}

主线程开始

主线程结束

新开辟的线程：<NSThread: 0x60400026bb40>{number = 3, name = (null)}

任务1执行 <NSThread: 0x60400026bb40>{number = 3, name = (null)}

任务2执行 <NSThread: 0x60400026bb40>{number = 3, name = (null)}

看到了么，dispatch_sync函数在新开辟的线程（number = 3）中执行，任务1和任务2也在这个线程中执行，而主线程结束在执行两个任务之前打印，所以它同步的线程是这个新线程，而不再是我们的主线程了。理解这点非常重要。

重点二：主线程+同步任务

我们将任务1的队列改为主队列，代码如下：

dispatch_sync(dispatch_get_main_queue(), ^{

NSLog(@"任务1执行 %@", [NSThread currentThread]);

[NSThread sleepForTimeInterval:4];

});

运行代码过后，直接崩溃，这里形成了死锁，很多文章在这个地方往往含糊其辞，这里需要重点说明一下（当然这是我的理解，可能会有错误，欢迎指出）。

解析：首先我们要明白，dispatch_sync函数是在主队列执行的，相当于主队列的一个任务，dispatch_sync任务执行完毕的条件是后边的block代码块执行完毕（而dispatch_async是立即返回的），所以，此刻主队列在等待dispatch_sync函数执行完毕；与此同时，我们将任务1也加入到了主队列中，任务1理所当然的会等待上一个任务执行完毕才会执行（FIFO原则）。

而不巧的是，上一个任务就是dispatch_sync函数，dispatch_sync函数执行完毕需要任务1执行完毕。这就异常尴尬了，所以就造成了死锁，如果没看明白多看几遍，理解了这个地方死锁的原因你将触摸到GCD的精髓。

这也就是之前代码顺利运行的原因，dispatch_sync函数加入到了mainQueue队列中，任务1加入到了serialQueue队列中，就不存在相互等待从而造成死锁了。

2、串行队列+异步任务

同样是之前的代码，把dispatch_sync改为dispatch_async就OK了，我还是贴上全部代码吧，照顾伸手党哈哈??

dispatch_queue_t mainQueue = dispatch_get_main_queue();

dispatch_queue_t serialQueue = dispatch_queue_create("com.myProject.queue2", DISPATCH_QUEUE_SERIAL);

NSLog(@"主队列：%@ \n创建的串行队列：%@", mainQueue, serialQueue);

NSLog(@"主线程：%@", [NSThread currentThread]);

NSLog(@"主线程开始");

dispatch_async(serialQueue, ^{

NSLog(@"任务1执行 %@", [NSThread currentThread]);

[NSThread sleepForTimeInterval:4];

});

dispatch_async(serialQueue, ^{

NSLog(@"任务2执行 %@", [NSThread currentThread]);

[NSThread sleepForTimeInterval:4];

});

NSLog(@"主线程结束");

主队列：<OS_dispatch_queue_main: com.apple.main-thread>

创建的串行队列：<OS_dispatch_queue: com.myProject.queue2>

主线程：<NSThread: 0x60000006aa80>{number = 1, name = main}

主线程开始

主线程结束

任务1执行 <NSThread: 0x60000007ab00>{number = 3, name = (null)}

任务2执行 <NSThread: 0x60000007ab00>{number = 3, name = (null)}

看到了么，由于任务是异步的，执行了dispatch_async函数过后主线程立即返回打印了主线程结束，我们的两个任务没有对主线程基本没有造成阻塞（因为执行dispatch_async函数也算是一点点阻塞吧??）。GCD自动为我们开辟了一个线程，而任务1和任务2加入的队列仍然是串行队列，所以任务2是在任务1结束之后执行的。(没有加太多打印日志，最好上机试试)

重点：若这里把serialQueue换成主队列 mainQueue会发生什么呢？

这里就不上代码了。

队列换成主队列过后，任务1和任务2执行的线程就变成了主线程，并且任务1和任务2执行的时候会造成主线程阻塞，这都是正常的。在主队列异步执行任务，这是我们用来获取主线程且不会死锁的常用做法，也是我们开发中用来刷新UI经常会使用到的方法，如下：

dispatch_async(dispatch_get_main_queue(), ^{

//更新UI

});

记住：针对于串行队列，dispatch_async函数在哪个线程执行并不影响dispatch_async内部的代码块在哪个线程执行（这和dispatch_sync函数不同），这取决于任务所在的串行队列，串行队列会根据任务进入的顺序安排同一个线程依次执行。所以，在想要回到主线程的时候，在任意线程调用上述代码就可以轻松的获取到主线程。

3、并行队列+同步任务

说明一下，使用系统提供的全局队列和自己创建的并行队列没有什么本质的区别，在日常开发中，少量的任务建议使用全局队列，如果任务处理量大，那就自己创建一个并且管理它。

dispatch_queue_t globalQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

NSLog(@"主线程：%@", [NSThread currentThread]);

NSLog(@"主线程开始");

dispatch_sync(globalQueue, ^{

NSLog(@"任务1执行 %@", [NSThread currentThread]);

[NSThread sleepForTimeInterval:4];

});

dispatch_sync(globalQueue, ^{

NSLog(@"任务2执行 %@", [NSThread currentThread]);

[NSThread sleepForTimeInterval:4];

});

NSLog(@"主线程结束");

主线程：<NSThread: 0x60400007a1c0>{number = 1, name = main}

主线程开始

任务1执行 <NSThread: 0x60400007a1c0>{number = 1, name = main}

任务2执行 <NSThread: 0x60400007a1c0>{number = 1, name = main}

主线程结束

细心的朋友可能发现了，这和串行队列+同步任务执行逻辑一模一样。

是的，只要dispatch_sync在主线程执行了，就注定了里面的任务会在主线程执行，而这里虽然队列是并行队列，但它也没办法，它也不允许找第二个线程来并行执行任务2了，所以串行队列+同步任务和并行队列+同步任务并没有表象上的区别。

4、并行队列+异步任务

需要上机测试才能很好理解

dispatch_queue_t globalQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

NSLog(@"主线程：%@", [NSThread currentThread]);

NSLog(@"主线程开始");

dispatch_async(globalQueue, ^{

NSLog(@"任务1执行 %@", [NSThread currentThread]);

[NSThread sleepForTimeInterval:4];

});

dispatch_async(globalQueue, ^{

NSLog(@"任务2执行 %@", [NSThread currentThread]);

[NSThread sleepForTimeInterval:4];

});

dispatch_async(globalQueue, ^{

NSLog(@"任务3执行 %@", [NSThread currentThread]);

[NSThread sleepForTimeInterval:4];

});

dispatch_async(globalQueue, ^{

NSLog(@"任务4执行 %@", [NSThread currentThread]);

[NSThread sleepForTimeInterval:4];

});

NSLog(@"主线程结束");

主线程：<NSThread: 0x60000006ec00>{number = 1, name = main}

主线程开始

主线程结束

任务1执行 <NSThread: 0x600000273000>{number = 3, name = (null)}

任务3执行 <NSThread: 0x6040002775c0>{number = 4, name = (null)}

任务4执行 <NSThread: 0x600000273040>{number = 5, name = (null)}

任务2执行 <NSThread: 0x600000273080>{number = 6, name = (null)}

这里需要说明的是，四个不同的线程同时运作，任务1到任务4几乎都是同时执行的，可以不严密的说是并发且并行，这就是并行队列做的事情。而且主线程结束是在任务执行之前打印的，说明主线程没有受这几个任务的影响，这也体现了异步任务的功能。

注意：并不是并行队列同时执行几个任务就会开辟几个线程，我们知道并行队列也是FIFO的取出任务来执行，所以有一种可能是：后面某个任务还没取出的时候，前面某个任务已经结束了，这时候并行队列就会复用前面那个已经结束任务所在的线程了。

这种组合在各大开源框架和日常开发中都经常会用到，后台执行耗时操作的特性极大的提高了人机交互的流畅度。

三、GCD一些其他用法

1、dispatch_barrier 栅栏

dispatch_barrier使用的场景之一就是在并行队列中强行插入一个栅栏，以达到我们为并行任务的分组控制（举个例子，有多个并行的任务，我们需要让其中几个任务执行结束过后，再通过一些计算得到后面几个任务需要的东西，这就需要用到栅栏了）。

dispatch_queue_t concurrentQueue = dispatch_queue_create("com.myProject.queue2", DISPATCH_QUEUE_CONCURRENT);

dispatch_queue_t globalQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

NSLog(@"主线程：%@", [NSThread currentThread]);

NSLog(@"主线程开始");

dispatch_async(concurrentQueue, ^{

NSLog(@"任务1执行 %@", [NSThread currentThread]);

[NSThread sleepForTimeInterval:4];

});

dispatch_async(concurrentQueue, ^{

NSLog(@"任务2执行 %@", [NSThread currentThread]);

[NSThread sleepForTimeInterval:4];

});

dispatch_barrier_sync(concurrentQueue, ^{

NSLog(@"任务barrier执行 %@", [NSThread currentThread]);

[NSThread sleepForTimeInterval:4];

});

dispatch_async(concurrentQueue, ^{

NSLog(@"任务3执行 %@", [NSThread currentThread]);

[NSThread sleepForTimeInterval:4];

});

dispatch_async(concurrentQueue, ^{

NSLog(@"任务4执行 %@", [NSThread currentThread]);

[NSThread sleepForTimeInterval:4];

});

NSLog(@"主线程结束");

主线程：<NSThread: 0x604000064640>{number = 1, name = main}

主线程开始

任务2执行 <NSThread: 0x6000002792c0>{number = 3, name = (null)}

任务1执行 <NSThread: 0x60400007f080>{number = 4, name = (null)}

任务barrier执行 <NSThread: 0x604000064640>{number = 1, name = main}

主线程结束

任务4执行 <NSThread: 0x6000002792c0>{number = 3, name = (null)}

任务3执行 <NSThread: 0x60400007f080>{number = 4, name = (null)}

说明一下：

主线程开始执行
任务都加入自定义的并行队列，排在barrier前面的任务1任务2开始并行执行
等到任务1和任务2都执行完毕，开始执行barrier里面任务
等到barrier里任务执行完毕，主线程结束，并且任务3任务4开始并行执行

注意一：我这上面用的是dispatch_barrier_sync，所以barrier里面的任务会在主线程执行，而且会占用主线程导致主线程结束在barrier任务执行结束之后才打印。

如果我们将dispatch_barrier_sync换成dispatch_barrier_async，执行barrier任务的线程就由并行队列自行安排，不会影响主线程，主线程结束将在并行任务开始执行之前打印。(可自行试试)

注意二：dispatch_barrier_sync和dispatch_barrier_async都会阻塞传入的队列，并且这个传入的队列不能是系统提供的主队列和全局队列，否则就失去了使用它们的意义，就和使用dispatch_async和dispatch_sync一样的效果了。

关于栅栏更多的细节这里就不多说了，可以去看看苹果官方文档，了解了解就行了，用得也不多。

2、dispatch_after 延时执行

延时函数，大家不陌生，需要注意的是，我们dispatch_after函数一旦返回就无法取消，所以有些时候我们还是喜欢用NSObject的实例方法performSelector: withObject: afterDelay:，因为可以用cancelPreviousPerformRequestsWithTarget:等方法取消这个还没到时间的延时操作；还有一点是，dispatch_after最好在主队列执行。

dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{

NSLog(@"延时了两秒");

});

3、dispatch_once 实现单例模式

我见过有人使用下面这种方式实现单例模式：

static AnyObject obj = nil;

if (!obj) {

//初始化

}

这种方式明显是线程不安全的，正确高效的方法如下：

static AnyObject obj = nil;

static dispatch_once_t onceToken;

dispatch_once(&onceToken, ^{

//初始化

});

该dispatch_once是线程安全的，并且官方称其性能很好，所以如果大家有兴趣可以测试下性能问题。

4、dispatch_apply 快速迭代

用法很简单，for循环和枚举遍历都是挨着把元素取出来，dispatch_apply可以快速同时遍历，用法简单：

dispatch_apply(6, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^(size_t i) {

//执行任务

});

5、调度组：dispatch_group

一个金典的使用场景就是获取到所有任务完成的回调：

//创建调度组

dispatch_group_t group = dispatch_group_create();

//获取全局队列

dispatch_queue_t globalQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

NSLog(@"主线程：%@", [NSThread currentThread]);

NSLog(@"主线程开始");

dispatch_group_async(group, globalQueue, ^{

NSLog(@"任务1执行 %@", [NSThread currentThread]);

[NSThread sleepForTimeInterval:4];

});

dispatch_group_async(group, globalQueue, ^{

NSLog(@"任务2执行 %@", [NSThread currentThread]);

[NSThread sleepForTimeInterval:4];

});

dispatch_group_notify(group, globalQueue, ^{

NSLog(@"任务全部完成");

});

NSLog(@"主线程结束");

主线程：<NSThread: 0x600000066b00>{number = 1, name = main}

主线程开始

主线程结束

任务1执行 <NSThread: 0x60000027c0c0>{number = 3, name = (null)}

任务2执行 <NSThread: 0x604000261c40>{number = 4, name = (null)}

任务全部完成

当然，你可以将队列换做主队列或其他队列，调度组同样能监听到任务全部完成的回调，我们还可以这样写：

//创建调度组

dispatch_group_t group = dispatch_group_create();

//获取全局队列

dispatch_queue_t globalQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

NSLog(@"主线程：%@", [NSThread currentThread]);

NSLog(@"主线程开始");

dispatch_group_enter(group);

dispatch_async(globalQueue, ^{

NSLog(@"任务1执行 %@", [NSThread currentThread]);

[NSThread sleepForTimeInterval:4];

dispatch_group_leave(group);

});

dispatch_group_enter(group);

dispatch_async(globalQueue, ^{

NSLog(@"任务2执行 %@", [NSThread currentThread]);

[NSThread sleepForTimeInterval:4];

dispatch_group_leave(group);

});

dispatch_group_notify(group, globalQueue, ^{

NSLog(@"任务全部完成");

});

//dispatch_group_wait(group, DISPATCH_TIME_FOREVER);

NSLog(@"主线程结束");

两种方式都能达到同样的效果，需要注意的是dispatch_group_enter和dispatch_group_leave需要一一对应。注意到上面我注释了一句代码么dispatch_group_wait(group, DISPATCH_TIME_FOREVER);，我们将它的注释取消，会发现主线程被阻塞了，当我们的两个任务都执行完毕过后才会打印主线程结束。

写在后面

对于这几篇文章，GCD是我重点讲述的东西，多做实验多研究开源库，你会发现多线程也没那么难。