iOS GCD死锁案列与分析

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

串行与并行指的是的是队列. 而同步与异步指的则是线程. 最大的区别在于. 同步线程要阻塞当前线程, 必须要等待同步线程中的任务执行完, 返回以后, 才能继续执行下一任务. 而异步线程则是不用等待, 可直接跳过异步线程中的任务执行下一个任务. 下面通过代码来分析:

• 案例一: 在主队列中开启同步任务

/**
 在主队列中开启同步任务
 */
- (void)test_sync_main_queue {
    dispatch_sync(dispatch_get_main_queue(), ^{
        NSLog(@"任务1 %@", [NSThread currentThread]);
    });
}

产生死锁.
具体分析: 同步任务不会开启新的线程, 而同时将任务1加入到了main_queue中. 此时main_queue中已经存在任务-test_sync_main_queue(). 根据FIFO原则, 任务1需要等待-test_sync_main_queue()执行完毕才能执行. 而-test_sync_main_queue()则需要等待任务1执行完毕. 所以产生死锁.

• 案例二 : 同步任务 + 主线程队列:

/**
 同步任务 + 主线程队列
 */
- (void)test_sync_main_queue {
    NSLog(@"任务1 %@", [NSThread currentThread]);
    dispatch_sync(dispatch_get_main_queue(), ^{
        NSLog(@"任务2 %@", [NSThread currentThread]);
    });
    NSLog(@"任务3 %@", [NSThread currentThread]);
}

打印结果:

2019-08-04 10:52:04.235150+0800 testGCD[56110:350275] 任务1 {number = 1, name = main}
(lldb) 

分析:

1. 首先, 将[任务1 、同步线程、任务3]加入 主线程串行队列中. 执行任务1.
2. 遇到同步任务,将会阻塞当前线程, 等待任务2执行完毕再执行下边的任务. 将任务2加入主线程串行队列中, 因队列遵循FIFO原则, 这个时候任务2会添加到任务3后边.
3. 任务3需要等待线程阻塞完毕才能执行, 要解除线程阻塞需要完成任务2. 然而这个时候, 在主线程串行队列中, 任务2排在了任务3后边, 需要等待任务3执行完毕. 就这样 任务2和任务3相互等待, 造成死锁.

• 案例三 : 同步任务 + 并行队列:

/**
 同步任务 + globle_queue
 */
- (void)test_sync_globle_queue {
    NSLog(@"任务1 %@", [NSThread currentThread]);
    dispatch_sync(dispatch_get_global_queue(0, 0), ^{
        NSLog(@"任务2 %@", [NSThread currentThread]);
    });
    NSLog(@"任务3 %@", [NSThread currentThread]);
}

打印结果如下:

2019-08-04 11:12:47.324666+0800 testGCD[56144:357242] 任务1 {number = 1, name = main}
2019-08-04 11:12:47.324819+0800 testGCD[56144:357242] 任务2 {number = 1, name = main}
2019-08-04 11:12:47.324900+0800 testGCD[56144:357242] 任务3 {number = 1, name = main}

1. 首先执行任务1,
2. 遇到同步线程,将任务2加入到一个dispatch_get_global_queue全局并行队列中. 当前线程阻塞, 等待任务2执行完毕.
   3, 任务2执行完毕, 执行任务3.

• 案例四 : 异步线程 + 串行队列(非主线程)

/**
 异步线程 + 串行队列(非主线程)
 */
- (void)test_async_serialQueue {
    dispatch_queue_t serialQueue = dispatch_queue_create("test_serialQueue", DISPATCH_QUEUE_SERIAL);
    NSLog(@"任务1 %@", [NSThread currentThread]);
    dispatch_async(serialQueue, ^{
        NSLog(@"任务2 %@", [NSThread currentThread]);
        
        dispatch_sync(serialQueue, ^{
            NSLog(@"任务3 %@", [NSThread currentThread]);
        });
        NSLog(@"任务4 %@", [NSThread currentThread]);
    });
    NSLog(@"任务5 %@", [NSThread currentThread]);
}

打印结果如下:

2019-08-04 11:22:15.947534+0800 testGCD[56202:361235] 任务1 {number = 1, name = main}
2019-08-04 11:22:15.947739+0800 testGCD[56202:361235] 任务5 {number = 1, name = main}
2019-08-04 11:22:15.947825+0800 testGCD[56202:361285] 任务2 {number = 3, name = (null)}
(lldb) 

1. 首先执行任务1, 遇到异步线程, 将[任务2, 同步线程, 任务4]加入serialQueue串行队列中.
2. 由于是异步线程, 可以不用等待执行下边的任务, 所以任务2,任务5顺序不一定.
3. 执行任务2, 遇到同步线程. 将任务3加入serialQueue串行队列中, 这个时候任务4在任务3前边.
4. 任务4需要等待任务3执行完成才能执行, 但是根据FIFO原则, 任务3又需要等待任务4完成. 造成死锁.

• 案例五 : 异步线程 + 不同队列

/**
 异步线程 + 不同队列
 */
- (void)test_async_queue {
    NSLog(@"任务1 %@", [NSThread currentThread]);
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        NSLog(@"任务2 %@", [NSThread currentThread]);
        dispatch_sync(dispatch_get_main_queue(), ^{
            NSLog(@"任务3 %@", [NSThread currentThread]);
        });
        NSLog(@"任务4 %@", [NSThread currentThread]);
    });
    NSLog(@"任务5 %@", [NSThread currentThread]);
}

打印结果如下:

2019-08-04 11:31:18.781816+0800 testGCD[56236:364557] 任务1 {number = 1, name = main}
2019-08-04 11:31:18.782002+0800 testGCD[56236:364557] 任务5 {number = 1, name = main}
2019-08-04 11:31:18.782032+0800 testGCD[56236:364603] 任务2 {number = 3, name = (null)}
2019-08-04 11:31:18.785523+0800 testGCD[56236:364557] 任务3 {number = 1, name = main}
2019-08-04 11:31:18.785659+0800 testGCD[56236:364603] 任务4 {number = 3, name = (null)}

1. 首先将[任务1, 异步线程, 任务5]放入主线程队列中, 执行任务1,遇到异步线程.
2. 将异步线程中[任务2, 同步线程, 任务4]加入全局队列中. 由于异步线程可以不用等待, 所以任务2和任务5顺序不确定.
3. 执行任务2, 遇到同步线程, 将任务3, 加入主线程队列, 此时任务3在任务5后边. 线程将阻塞, 等待任务3完成, 执行任务4.
   4, 故而: 任务2和任务5顺序不确定. 任务3一定在任务5和任务2之后, 任务4一定在任务3后.

• 案例六: 异步线程 + 同步线程

/**
 异步线程 + 同步线程: 
 */
- (void)test_async_sync {
    
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        NSLog(@"任务1 %@", [NSThread currentThread]);
        dispatch_sync(dispatch_get_main_queue(), ^{
            NSLog(@"任务2 %@", [NSThread currentThread]);
        });
        NSLog(@"任务3 %@", [NSThread currentThread]);
    });
    NSLog(@"任务4 %@", [NSThread currentThread]);
    while (1) { }
    NSLog(@"任务5 %@", [NSThread currentThread]);
}

打印结果如下:

2019-08-04 15:58:14.640076+0800 testGCD[56451:392646] 任务4 {number = 1, name = main}
2019-08-04 15:58:14.640079+0800 testGCD[56451:392695] 任务1 {number = 3, name = (null)}

1. 首先看有什么任务添加到了mian_queue中去:[异步线程、任务4、while死循环、任务5].
2. 由于是异步线程, 所以任务4不用等待, 任务4和任务1顺序不一定.
3. 任务4执行完成后, 进入死循环, 主线程被阻塞.
4. 加入global_queue异步队列的任务有:[任务1、同步线程、任务3], 任务1指向完毕后, 进入同步线程, 将任务2加入了mian_queue. 然而此时mian_queue被死循环所堵塞, 任务2无法完成.
5. 任务3等待任务2完成才能执行, 任务2无法执行, 故而任务3无法执行.
6. 在死循环后的任务5无法执行.