作者: brighttj（@saitjr
题目: 五个案例让你明白GCD死锁
网址：http://www.brighttj.com/ios/ios-gcd-deadlock.html

死锁一直都是在使用多线程时，需要注意的一个问题。以前对同步、异步，串行、并行只有一个模糊的概念，对于各种情况的死锁也只有大概的了解，因此觉得应该整理一下！以上这篇文章是关于死锁情况的分析，个人觉得非常好的一篇文章。

一. 串行与并行

在使用GCD的时候，我们会把需要处理的任务放到Block中，然后将任务追加到相应的队列里面，这个队列，叫做 Dispatch Queue。然而，存在于两种 Dispatch Queue，一种是要等待上一个执行完，再执行下一个的 Serial Dispatch Queue，这叫做串行队列；另一种，则是不需要上一个执行完，就能执行下一个的 Concurrent Dispatch Queue，叫做并行队列。这两种，均遵循FIFO原则。

举个简单的例子，在三个任务中输出1，2，3，串行队列输出是有序的1，2，3，但是并行队列的先后顺序就不一定了。

那么，并行队列又是怎么执行的呢？

虽然可以同时处理多个任务，但是并行队列的处理量，还是要根据当前系统的状态来。如果当前系统状态最多处理2个任务，那么1，2会排在前面，3什么时候处理，就看1或者2谁先完成，然后3接在后面。

二. 同步与异步

串行与并行针对的是队列，而同步与异步，则是针对线程。最大的区别在于，同步线程要阻塞当前线程，必须等待同步线程中的任务执行完，返回以后，才能继续执行下一任务，而异步线程则是不用等待。

具体看案例进行分析。

三. GCD API

GCD API 很多，这里仅介绍本文用到的。

1. 系统标准提供的两个队列

// 全局队列，也是一个并行队列
dispatch_get_global_queue

// 主队列，在主线程中运行，因为主线程只有一个，所以这是一个串行队列
dispatch_get_main_queue

**2. 除此之外，还可以自己生成队列 **

 // 从DISPATCH_QUEUE_SERIAL看出，这是串行队列

dispatch_queue_create("com.demo.serialQueue", DISPATCH_QUEUE_SERIAL) 

 // 同理，这是一个并行队列

 dispatch_queue_create("com.demo.concurrentQueue", DISPATCH_QUEUE_CONCURRENT) 

** 3. 接下来是同步与异步线程的创建 **

dispatch_sync(..., ^(block)) // 同步线程

dispatch_async(..., ^(block)) // 异步线程

四. 案例与分析

案例一:

NSLog(@"1"); // 任务1

dispatch_sync(dispatch_get_main_queue(), ^{

    NSLog(@"2"); // 任务2

});

NSLog(@"3"); // 任务3

** 结果，控制台输出: **

1

** 分析: **

dispatch_sync 表示一个同步线程

dispatch_get_main_queue 表示运行在主线程中的主队列。

任务2是同步线程的任务。

a. 首先，执行任务1，这是肯定没问题的，只是接下来，程序遇到了同步线程，那么它会进入等待，等待任务2执行完，然后执行任务3.
b. 但是这是队列，主队列有任务来，当然会将任务加到对尾，然后FIFO原则执行任务。因此任务2就会被加到主队列最后，任务3排在任务2前面，这样问题来了:

** 由于同步线程的阻塞，任务3要等任务2执行完才能执行，任务2由于排在任务3后面，意味着任务2要在任务3执行完后才能执行，所以他们进入了相互等待的局面。**

** 如图所示 : **

案例一.png

** 案例二 ： **

NSLog(@"1"); // 任务1

dispatch_sync(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0), ^{

NSLog(@"2"); // 任务2

});

NSLog(@"3"); // 任务3

** 结果，控制台输出 : **

1
2
3

** 分析 **

a. 首先，执行任务1，接下来会遇到一个同步线程，程序会进入等待。等待任务2执行完成以后，才能继续执行任务3.

b. 从dispatch_get_global_queue可以看出，任务2被加入到了全局的并行队列中，当并行队列执行完成任务2以后，返回主队列，继续执行任务3.

** 如图所示: **

案例2.png

** 案例三 : **

dispatch_queue_t queue = dispatch_queue_create("com.demo.serialQueue", DISPATCH_QUEUE_SERIAL);

NSLog(@"1"); // 任务1

dispatch_async(queue, ^{

    NSLog(@"2"); // 任务2

    dispatch_sync(queue, ^{  

        NSLog(@"3"); // 任务3

    });

    NSLog(@"4"); // 任务4

});

NSLog(@"5"); // 任务5

** 结果，控制台输出: **

1
5
2
// 5 和 2 的顺序 不一定

** 分析： **
这个案例没有使用系统提供的串行或并行队列，而是自己通过dispatch_queue_create函数创建了一个DISPATCH_QUEUE_SERIAl 的串行队列。

a. 首先，执行任务1，接下来遇到异步线程，将[任务2、同步线程、任务4]加入串行队列中。因为是异步线程，所以在主线程中的任务5，不必等待异步线程中所有的任务完成；

b. 因为任务5不必等待，所以2和5的输出顺序不能确定。

c. 任务2执行完以后，遇到同步线程，这是串行队列进入等待，等待任务3执行完之后，执行任务4.

d. 又因为队列先进先出，所以任务4比任务3早加入队列，所以，任务3要等待任务4执行完成以后，才能执行。

** 同时任务3所在的同步线程会阻塞，所以任务4必须等待任务3执行完之后再执行，这就陷入了无限的等待中，造成了死锁。**

** 如图所示: **

案例3.png

** 案例四 :**

NSLog(@"1"); // 任务1

dispatch_async(dispatch_get_global_queue(0, 0), ^{

   NSLog(@"2"); // 任务2

    dispatch_sync(dispatch_get_main_queue(), ^{

        NSLog(@"3"); // 任务3

    });

    NSLog(@"4"); // 任务4

});

NSLog(@"5"); // 任务5

** 结果， 控制台输出: **

1
2
5
3
4
// 5 和 2 顺序不一定

** 分析： **

a. 首先，将【任务1， 异步线程， 任务5】加入到Main Queue中，异步线程中的任务是:【任务2， 同步线程， 任务4】。

b. 所以一开始先执行任务1，然后将异步线程中的任务加入到Global Queue中，因为异步线程，所以任务5不用等待，结果就是2和5的输出顺序不一定。

c. 然后再看异步线程中的任务执行顺序，任务2执行完以后，遇到同步线程，将同步线程中的任务加入到Main Queue中，这是加入的任务3在任务5后面，当任务3执行完以后，没有了阻塞，程序继续执行任务4.

d. 从以上分析来看，得到的几个结果:1最先执行； 2和5的顺序不一定； 4一定在3的后面。

** 如图所示: **

案例4.png

** 案例5: **

dispatch_async(dispatch_get_global_queue(0, 0), ^{

    NSLog(@"1"); // 任务1

    dispatch_sync(dispatch_get_main_queue(), ^{

        NSLog(@"2"); // 任务2

    });

    NSLog(@"3"); // 任务3

});

NSLog(@"4"); // 任务4

while (1) {

}

NSLog(@"5"); // 任务5

** 结果，控制台输出 **

1
4
// 1和4顺序不一定

** 分析 **

a. Main Queue中加入了任务【异步线程， 任务4， 死循环， 任务5】，而加入到Global Queue异步线程中的任务有【任务1， 同步线程， 任务3】。

b. 所以，第一个是异步线程，任务4不用等待，结果任务1和任务4执行属性不一定。

c.任务4执行完成后，程序进入死循环，Main Queue阻塞。但是加入到Global Queue的异步线程不受影响，继续执行任务1后面的同步线程。

d. 同步线程，将任务2加入到主线程，并且，任务3等待任务2完成以后才能执行。这是主线程已经被死循环阻塞了。所以任务2无法执行，当然任务3也无法执行，在死循环后面的任务5也无法执行。

f. 最后，只能得到1和4顺序不定的结果。

** 如图所示: **

案例五.png

五. 最后

送上一张喜欢的图片:

路.jpg