美文网首页iOS技术点基础别人的iOS精华
一篇专题让你秒懂GCD死锁问题!

一篇专题让你秒懂GCD死锁问题!

作者: DXSmile | 来源:发表于2016-02-21 02:01 被阅读2180次

    故事背景:

    GCD的死锁问题,一直是在使用多线程的时候,一个比较绕也必须要注意的问题,今天在工作中我们几个同事又讨论到了这个话题,通过和大伙的交流,发现不少的同事还是有绕不明白的地方, 我就想到,要不我来写一个关于GCD死锁的专题好了,于是就有了这篇关于GCD死锁的专题: (下方的理解,仅限于我个人的理解,有不妥的地方,望大家斧正!)

    如果您有任何意见或建议也可以通过邮件微博联系我

    环境信息:

    Mac OS X 10.11.3
    Xcode 7.2
    iOS 9.2


    阐述:

    1. 什么是GCD ?

    GCD,全称 Grand Central Dispatch。可翻译为”牛逼的中枢调度器”。它是纯C语言的,提供了非常多强大的函数。
    Grand是宏伟的、极重要的意思。

    GCD是提供了功能强大的任务和队列控制功能,相比于NSOperation更加底层,虽然现象苹果极力的推荐使用NSOperation来解决多线程问题, 但是,就目前市场上大部分企业的iOS开发团队而言, GCD仍然还是大头, NSOperation也只会逐步的来替代GCD, 因此在开线程的时候,如果不注意也会导致一些问题, 比如死锁。

    2.什么是GCD死锁 ?

    所谓死锁,通常指有两个线程A和B都卡住了,A在等B ,B在等A,相互等待对方完成某些操作。A不能完成是因为它在等待B完成。但B也不能完成,因为它在等待A完成。于是大家都完不成,就导致了死锁(DeadLock)。

    对于部分新手来说, 可能认为GCD死锁是很高端的操作系统层面的问题,离我很远,一般不会遇上。其实这种想法是非常错误的,因为只要简单三行代码(如果愿意,甚至写在一行就可以)就可以人为创造出死锁的情况,如:

    int main(int argc, const char * argv[]) {
        @autoreleasepool {
            dispatch_sync(dispatch_get_main_queue(), ^(void){
                NSLog(@"这里死锁了");
            });
        }
        return 0;
    }
    

    3. 要理解GCD死锁,必须先理解GCD的几个概念:

    &3.1串行与并行

    **串行和并行都是相对于队列而言的 **
    -队列(负责调度任务)
    -串行队列:一个接一个的调度任务
    -并发队列:可以同时调度多个任务

    在使用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接在后面。
    串行和并行就简单说到这里,关于它们的技术点其实还有很多,可以自行了解。

    &3.2 同步与异步

    串行与并行针对的是队列,而同步与异步,针对的则是线程。
    最大的区别在于,同步线程要阻塞当前线程,必须要等待同步线程中的任务执行完,返回以后,才能继续执行下一任务;而异步线程则是不用等待。
    仅凭这几句话还是很难理解,所以可以多准备几个案例,边分析边理解。

    &3.3 GCD API

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

    1. 系统标准提供的两个队列
    // 全局队列,一个特殊的并行队列
    dispatch_get_global_queue
    // 主队列,在主线程中运行,因为主线程只有一个,所以这是一个特殊的串行队列
    dispatch_get_main_queue
    
    1. 除此之外,还可以自己生成队列
    // 从DISPATCH_QUEUE_SERIAL看出,这是串行队列
    dispatch_queue_create("com.demo.serialQueue", DISPATCH_QUEUE_SERIAL)
    // 同理,这是一个并行队列
    dispatch_queue_create("com.demo.concurrentQueue", DISPATCH_QUEUE_CONCURRENT)
    
    1. 同步与异步线程的创建:
    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是同步线程的任务。
    • 任务3需要等待任务2结束之后再执行.

    首先执行任务1,这是肯定没问题的,只是接下来,程序遇到了同步线程,那么它会进入等待,等待任务2执行完,然后执行任务3。但这是主队列,是一个特殊的串行队列,有任务来,当然会将任务加到队尾,然后遵循FIFO原则执行任务。那么,现在任务2就会被加到最后,任务3排在了任务2前面,问题来了:

    任务3要等任务2执行完才能执行,任务2又排在任务3后面,意味着任务2要在任务3执行完才能执行,所以他们进入了互相等待的局面。【既然这样,那干脆就卡在这里吧】这就是死锁。

    案例1分析:

    案例二:当同步遇到了并行

    NSLog(@"1"); // 任务1
    dispatch_sync(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0), ^{
        NSLog(@"2"); // 任务2
    });
    NSLog(@"3"); // 任务3
    

    控制台输出结果为:

    1
    2
    3
    

    分析:
    首先执行任务1,接下来会遇到一个同步线程,程序会进入等待。等待任务2执行完成以后,才能继续执行任务3。从dispatch_get_global_queue可以看出,任务2被加入到了全局的并行队列中,当并行队列执行完任务2以后,返回到主队列,继续执行任务3。

    案例2分析:

    案例三: 咱们来点复杂一些的: 同步异步都有

    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
    // 2 和 5 的顺序不一定 , 3, 4, 没有输出
    

    分析:
    这个案例没有使用系统提供的串行或并行队列,而是自己通过dispatch_queue_create函数创建了一个DISPATCH_QUEUE_SERIAL的串行队列。
    1.执行任务1;
    2.遇到异步线程,将【任务2、同步线程、任务4】加入串行队列中。因为是异步线程,所以在主线程中的任务5不必等待异步线程中的所有任务完成;
    3.因为任务5不必等待,所以2和5的输出顺序不能确定;
    4.任务2执行完以后,遇到同步线程,这时,将任务3加入串行队列;
    5.又因为任务4比任务3早加入串行队列,所以,任务3要等待任务4完成以后,才能执行。但是任务3所在的同步线程会阻塞,所以任务4必须等任务3执行完以后再执行。这就又陷入了无限的等待中,造成死锁。

    案例3分析:

    案例四:异步遇到同步回主线程

    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
    // 2 和 5 顺序不一定
    

    分析:
    这个案例,我相信大家都熟悉,没错,这就是典型的异步加载数据,回调主线程更新UI那个案例;

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

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

    然后再看异步线程中的任务执行顺序。任务2执行完以后,遇到同步线程。将同步线程中的任务又回调加入到Main Queue中,这时加入的任务3在任务5的后面。

    当任务3执行完以后,没有了阻塞,程序继续执行任务4。

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

    案例4分析:

    案例五: 当我们典型案例4,遇到了主线程上出现无限循环的时候

    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 顺序不一定
    

    分析:

    和上面几个案例的分析类似,先来看看都有哪些任务加入了Main Queue:【异步线程、任务4、死循环、任务5】。

    在加入到Global Queue异步线程中的任务有:【任务1、同步线程、任务3】。

    第一个就是异步线程,任务4不用等待,所以结果任务1和任务4顺序不一定。

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

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

    最终,只能得到1和4顺序不定的结果。

    案例5分析:

    GCD死锁问题,我们就暂时讨论到这里,上面列举的5各案例,基本已经概括了GCD遇到的绝大多数情况了,以后有遇到其他情况的时候,再来补充,

    相关文章

      网友评论

      • 巫师学徒:图画得挺好,但关于并发和并行与线程之间关系没有讲清楚。建议作者重新修改一下文章,这样大家理解更清楚。
      • 77c5ddcc99e4:你所说的任务1 同步任务 任务3 如果没有任务3是不是就能正常走下去。实际是还是会死锁
      • kscorpio:还有一个问题 类似案例一 只不过 不是main这个串行队列, 而是新建一个串行队列 , 也不会死锁,
        有关这个情况 似乎有点明白 但是说不太清楚
        这么理解对么?
        如果将任务 加入到新的队列里, 虽然是在一个线程,但是新队列里任务排在第一位,立即执行 没有等待所以没有死锁?
        http://upload-images.jianshu.io/upload_images/814422-a8c3c9ef5a577c02.jpg?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240
      • kscorpio:有一个问题 案例一: 当同步遇到了串行
        如果将案例一的 串行队列 改成 一个并行队列, 为什么不会死锁
        并行和串行队列 都是FIFO , 同步执行的时候 都无法开启新线程

        dispatch_queue_t s_queue = dispatch_queue_create("标识符", DISPATCH_QUEUE_CONCURRENT);
        NSLog(@"Begin----%@", [NSThread currentThread]);

        dispatch_sync(s_queue, ^{
        NSLog(@"Task 1---%@", [NSThread currentThread]);
        });

        NSLog(@"End -----%@", [NSThread currentThread]);
      • da27c260cc85:有个问题想问一下, 在AFNetworking源码中, AFURLSessionManager.m#47行, 作者使用了主线程同步到子线程去执行一个block, 请问这个意义在于什么呢? 我一直都没有想明白. 为什么不直接在主线程执行
      • 半块:可以加上 这点 dispatch_async 会开辟新线程 但是dispatch_sync 不会开辟新线程
      • 刘小壮:我说说我的理解:首先说明一点,主队列属于串行队列,串行队列中只有一个线程。
        在主线程中正在执行时,执行到sync任务时会卡住主线程,并向主队列派发一个任务。这个任务想要被执行,需要主线程正在执行的代码执行完成才能被执行,而主线程此时正在被sync任务卡住,所以不能继续往下执行,当前被执行的代码就一直不能被执行下去。这样造成了一个等待问题,任务执行不下去就会死锁。

        并行队列不会造成死锁的原因是,虽然在当前并行队列的线程中卡住当前线程,但是并行队列派发sync任务的时候可以派发到其他线程中。并行队列是存在多个线程的,所以不会造成死锁。

        为什么async不会造成死锁,因为async不会卡住当前线程。假设在串行队列中,向串行队列中添加一个async任务,这个任务不会卡当前队列的执行,而是继续向下执行。执行完下面的代码后,再执行async任务。这也就是为什么在并行队列中,同一个方法中的async代码要比下面代码执行晚的原因。
        小怡情ifelse:@刘小壮 嗯这个我赞同,而且很多人转载 会误导人的
        刘小壮:@厦大 这不是重点,我想表达的意思很明确,这篇文章的观点是错的。
        小怡情ifelse:@刘小壮 并行队列是存在多个线程的。这句话你是理解错了吧?并行队列并不会默认开启多个线程,还是一个线程,只有dispatch_async才能开启多线程。
      • 刘小壮:请问,按照你文中的理解,那把案例三中的任务4去掉,也会死锁。而且这是在一个自定义的串行队列中,不存在主队列一直运行的问题,麻烦作者解释一下。
      • xxttw:案例1中的 同步主线程的任务2 先被加入到了主队列 不应该比 任务3先执行吗
        DXSmile:@Unc1eWang 案例一中,任务2是同步遇到了主队列,当主队列出现的时候,会等待后面的任务先执行,也就是任务2会等到任务3执行之后在执行, 而这里任务2又是同步的, 所以,任务3也在等待任务2 ,他们就会成为彼此等待了,死锁因此产生
      • 果啤:作者你好,请问向主队列提交同步执行的任务为什么会死锁,而向新创建的串行队列提交同步执行的任务却不会死锁? 案例一中你使用的是一个很特殊的串行队列->主队列 这不合适吧
        DXSmile:@果啤 对于你问的第三个问题, 案例一中, 是为了演示这种情况下的死锁问题, 所以我故意这样写的, 一般在开发的时候,我们是需要避免出现这样的问题的
        DXSmile:@果啤 你问的第二个问题, 新添加的串行队列到同步任务中, 如案例2, 这里是先添加了一个global的队列, 那么任务并不会被加到后面去, 而是直接加到当前任务的位置, 所以任务2会优先执行, 执行结束之后,再执行任务3, 所以不会死锁
        DXSmile:@果啤 不好意思 这么久了才看见你的提问, 第一个问题,主队列的实质也是一个串行队列, 遵守FIFO, 而同步执行的任务也是同样的原理, 同时遇到队列的时候, 队列里面的任务系统会自动加到其他任务的最后面去, 如案例一, 任务2被放到了任务3后面, 那么任务2需要等待任务3先完成才能继续执行, 而这是同步的, 所以,任务3也在等待任务2完成, 那么他们就造成了彼此等待, 这就是死锁
      • 鼻毛长长:案例一

        什么叫dispatch_sync表示同步线程?表示是什么意思?同步线程又是什么意思?

        什么叫任务2等待任务3 任务3等待任务2?意思说,如果没有任务3,任务2就不用等待,就不会死锁了?
        DXSmile:@鼻毛长长 线程同步的意思就是说,两个及两个以上的线程,是有执行顺利的, 需要一个一个的执行, 而异步则表示多个线程可以一起执行, 要理解案例一, 建议你可以再研究一下线程的同步和异步,
      • 40c6620494c9:还有一个问题。一个线程会有几个队列?
        49218e6f3692:@DXSmile 文章整体不错,有图但是真相不够具体,例如 dispatch_async(dispatch_get_main_queue(), ^{};会在本线程创建出一个队列来,number=1的线程显示2个正在执行的队列
        DXSmile:@偶像MJ 一般情况下来说,一个线程就处理一个队列,如果是多个队列 就放到不同的线程里面,
      • DXSmile:对于案例一, 程序是从上而下执行的, 但是对于主队列而言, 遇到主队列,程序会自动将主队列里面的任务加到执行顺序的最后面, 也就是说 任务2会被加到任务3后面来执行, 但是 同时任务2又位于同步队列中, 同步队列是需要执行结束之后,再执行后面的, 所以任务3也在等待任务2先执行, 那么这种情况下, 比如会死锁了
        o0oi1i:@DXSmile 我也有@偶像MJ的这个疑惑,万望解答
        小开_99:换种理解方式吧。任务1之后是需要阻塞住线程,即同步等待,block本身的执行是异步的,等于是说任务2是要回到主线程的,而主线程又被阻塞了,所以就死锁了
        40c6620494c9:@DXSmile 我想表达的意思是,程序中,是先任务2才能走到任务3.走到任务2的时候, 难道不是先把任务2加入主队列,等运行到任务3,再加到主队列。。。。我市这个意思。我知道,新加入主队列的任务会被自动排到队尾。。我不明白的是,为什么任务2会作为最后一个任务加进主队列。。
      • 40c6620494c9:案例一,既然任务2执行完,然后执行任务3,为什么在主队列中,任务2会在任务3后面。。难道不是按照程序从上往下加进主队列么。
        DXSmile:@developerFan 嗯你说对:+1:
        developerFan:案例一现象是没问题, 但是原因是有偏差的, 实际上, dispatch_sync函数本身即是一个任务,我梳理了一下:
        NSLog(@"%@",[NSThread currentThread]);// 任务1
        dispatch_sync(dispatch_get_main_queue(), ^{
        NSLog(@"sync----%@",[NSThread currentThread]);// 任务2-1
        });// 任务2
        // NSLog(@"%@",[NSThread currentThread]);// 任务3

        /* dispatch_sync, this function does not return until the block has finished
        基于以上原理
        因为本来就有main queue,任务在执行之前就有排序, 顺序: 1 2 3
        现在执行任务2, 任务2的一部分就是让任务2-1执行, 而且是放在主队列, 也就是这个main queue中来执行, main queue中现在的任务顺序就变成: 1 2 3 2-1(1已经执行完了,理论上已经不再这个队列了).
        然而, 任务2-函数的结束是以任务2-1完毕才会renturn, 然而任务2-1前面有3, 3前面有2在执行,这样一来就形成了dead lock, 其实3在这里可有可无,没有3, 依然会是死锁.
        */
        半块:@偶像MJ 我的理解是 因为编译的时候话会先把任务3 放到任务2之前。但是执行的时候会要先执行3在执行2 这样子就会相互死锁
      • 9e49bb632b7f:对于案例一:我把任务3去掉,也是会发生死锁,所以和 死锁和任务3 没有任何关系。。这个解释有点不理解
        DXSmile:@偶像MJ 如果是在单独的子线程中去测试, 结果也是一样的, 只要这个任务3处还有其他代码, 必然会死锁,
        40c6620494c9:@DXSmile 那我如果在单独的子线程中去测试的呢
        DXSmile:@习惯假装 首先你要确定你测试的时候是否在单独的子线程测试的,如果不是,那么你就是在主线程测试了,你去掉任务三,这种情况下系统会默认主线程就是任务三,而主线程是一直执行的,永远不会结束,那么要再去执行位于主队列的任务二,显然是一直执行不了的,所以同样是死锁
      • ROOKIE:感觉案例一: 当同步遇到了串行
        其实应该只有两个任务任务甲和乙。任务甲有三步骤打印1,同步提交block到主队列 ,打印3。任务乙是打印2(执行block).任务甲执行完同步提交block到主队列后。要等待任务乙的执行完毕。任务乙由于在任务甲的后面。对于串行队列的先进先出原则。任务乙又要等待任务甲的执行完毕。
        cb3fc6332154:嗯,你这个解释更好一些。
      • chenjipdc:说的很详细
      • laughingkid:案例4的输出,错误了.是不是笔误了.
        laughingkid:@DXSmile 还有你的任务排列,你以为是编译时的,还是运行时的?
        DXSmile:@DXSmile 现在改过来了, 谢谢你了 :smile:
        DXSmile:@laughingkid 嗯,确实是我笔误了, 是我把输出结果写错了 ,感谢您的斧正 :blush:
      • 512eb49f4260:楼主 :案例5中 控制台输出结果: 1 2 5 4 3 // 2和5顺序不一定,从分析结果来看 1 最先执行,2和5顺序不一定,4一定在3后面 这里矛盾了吧??
        40c6620494c9:@DXSmile 任务3和任务2,5之间的顺序呢??
        DXSmile:@DXSmile 现在改过来了, 谢谢你了 :smile:
        DXSmile:@Jz_Evil 呃 抱歉, 我笔误了, 是我把输出结果写错了 ,感谢您的斧正 :blush:
      • 花轮丨:学习了!

      本文标题:一篇专题让你秒懂GCD死锁问题!

      本文链接:https://www.haomeiwen.com/subject/ucwvkttx.html