GCD死锁之探究

先看代码

- (void)test9 {
    dispatch_queue_t myQueue = dispatch_queue_create("come.my.gcd", DISPATCH_QUEUE_SERIAL);
    dispatch_sync(myQueue, ^{
        NSLog(@"+++++++++ 1");
        dispatch_sync(myQueue, ^{
            NSLog(@"+++++++++ 2");
        });
    });
}

控制台只会打印

2018-01-03 16:35:01.315736+0800 GCD练习[3327:197445] +++++++++ 1

因为产生了死锁

猜测下，myQueue的里面有一把锁，这把锁确保当队列是serial dispatch queue(串行)时，只有一个block执行，当执行到block 1时(按照先后顺序命名为 block 1, block 2)，开始加锁，只有当block 1执行完，才会释放。但是同时block 1又同步派发了一个任务block 2,啥意思，同步派发就意味着block 1会被阻塞，直到block 2被执行完成；
问题来了，block 2要执行的前提就是myQueue的这把锁被block 1释放，但block 1释放这把锁的前提又是block 1执行完成，OK 完美的死循环。

文字看着有点头痛。先上一段伪代码吧

- (void)test10 {
    dispatch_queue_t queue = dispatch_queue_create("haha", DISPATCH_QUEUE_SERIAL);
    //同步
    dispatch_sync(queue, block)
    {
        if (queue == 串行队列) {
            lock(queue.lock);//每个串行queue都有自己唯一的锁
        }
        //调用block
        block();

        //解锁
        if (queue == 串行队列) {
            unlock(queue.lock);//每个串行queue都有自己唯一的锁
        }
    }
    //异步
    dispatch_async(queue, block){
        if (queue != mainQueue) {
            //创建新的线程,执行任务
        } else {
            //那就不创建新线程，直接执行下面的代码了
        }
        //只有串行队列才会上锁
        if (queue == 串行队列) {
            lock(queue.lock);//每个串行queue都有自己唯一的锁
        }
        if (queue == 并行队列) {
            //是并行队列。就创建新线程
           Thread myThread =  createNewThread();
            //在新的线程李执行任务 block();
            myThread(
            //调用block
                     block();
            ) else {//不是并行队列
                //调用block
                block();

            }
        }
        
        //解锁
        if (queue == 串行队列) {
            unlock(queue.lock);
        }
    }
}

现在就用伪代码来解释下开头的例子

- (void)test11 {
    dispatch_queue_t myQueue = dispatch_queue_create("come.my.gcd", DISPATCH_QUEUE_SERIAL);
    dispatch_sync(myQueue, ^{//设置为block 1
        if (myQueue == 串行队列) {
            //上锁
            lock(myQueue.lock);
        }
        NSLog(@"+++++++++ 1");
        dispatch_sync(myQueue, ^{//设置为block 2
            if (myQueue == 串行队列) {
                lock(myQueue.lock);//block 2不能上锁，因为block 1已经lockle ,而且block 1还没有unlock
                //所以造成死锁了，block 2会等待block 1 unlock,但是block 1的unlock 必须等待block 2执行完才会调用，所以 block 2 一直在等待 block 1,block 1又在等block 2执行完 。。。
                //一个完美的环
                // 这里有个重点：queue.lock每个queue有自己唯一的lock

                //所以只有同一个queue的任务（block）才会造成死锁，因为lock()的参数，如果是不同的锁，肯定是可以上锁成功的，

            }
            NSLog(@"+++++++++ 2");
            if (myQueue == 串行队列) {
                unlock(myQueue.lock);
            }
        });
    });
}

那要怎么执行第二步呢

目前我想到了有两种

1. 将队列由DISPATCH_QUEUE_SERIAL修改为DISPATCH_QUEUE_CONCURRENT
2. 嵌套使用串行队列(同一个)，会产生死锁，所以将第二个队列替换为dispatch_get_main_queue
   那什么情况会发生死锁呢，异步执行block可定不会产生死锁，
   修改下代码：

dispatch_async(dispatch_get_global_queue(0,0), ^(void){
    NSLog(@"我进来了");
});

总结一点，异步不会产生死锁。
产生死锁的代码

dispatch_sync(dispatch_get_main_queue(), ^(void){
            NSLog(@"这里死锁了");
        });

产生死锁的原因，最重要的一点就是在主线程里执行dispatch_sync方法，这是个同步方法，block执行完是不会返回。如果是异步的，那就是立即返回，就不会阻塞主线程了。
所以，在GCD中需要关心的是同步还是异步执行，以及把block加到哪个队列中（串行还是并发）
之前有讲到，在同步执行时，向并发队列添加任务，是不会产生死锁的。
导致死锁的原因是在串行队列中添加block,而block一直在等前面的任务处理完才会执行，导致死锁。
产生死锁的原因猜测是：

在某一个串行队列中，同步的向这个队列中添加block

比如同步的向一个串行队列添加任务，并不一定会死锁，比如

dispatch_queue_t serialQueue = dispatch_queue_create("serialQueue", NULL);

dispatch_sync(serialQueue, ^{
NSLog(@"开启了一个异步任务task，当前线程：%@", [NSThread currentThread]);

});

分析一下代码，dispatch_sync不是将主线程给阻塞了吗，那为什么serialQueue中的任务还能在主线程里执行
猜想哈 在主线程里有两个队列，一个是main thread queue ，另一个是serialQueue，现在dispatch_sync只是把main queue给阻塞了，但serialQueue没有被阻塞，所以serialQueue中的任务任然可以在主线程执行