iOS基础 - GCD：线程中的代码执行顺序 | 死锁

▶ 线程死锁

死锁：是指两个或两个以上的进程（线程）在执行过程中，因争夺资源（如数据源，内存等。注：变量不是资源）而造成的一种互相等待的现象！若无外部处理作用，它们都将无限等待

死锁形成的原因有

A. 系统资源不足
B. 进程（线程）推迸的順序不恰当
C. 资源分配不当

死锁形成的条件有
A. 互斥条件：所谓互斥就是进程在某一时间内独占资源
B. 请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放
C. 不剥夺条件：进程已获得资源，在木使用完之前，不能强行剥夺
D. 循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系

▶ 代码示例

测试一：请尝试说出以下代码的执行顺序

#import "ViewController.h"
// 并行队列
#define concurrentQueueA   dispatch_queue_create("concurrentQueueA", DISPATCH_QUEUE_CONCURRENT)
#define concurrentQueueB   dispatch_queue_create("concurrentQueueB", DISPATCH_QUEUE_CONCURRENT)
// 串行队列
#define serialQueueA   dispatch_queue_create("concurrentQueueA", DISPATCH_QUEUE_SERIAL)
#define serialQueueB   dispatch_queue_create("concurrentQueueB", DISPATCH_QUEUE_SERIAL)
// 全局队列
#define globalQueue    dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0)
// 主队列
#define mainQueue      dispatch_get_main_queue()

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    
    [self DemoOne];
    [self DemoTwo];
    [self DemoThree];
    [self DemoFour];
    [self DemoFive];
    [self DemoSix];
    [self DemoSeven];
}

//--------------------- 测试1 ---------------------
- (void)DemoOne{
    
    NSLog(@"任务1");
    
    dispatch_async(concurrentQueueA,^{
        NSLog(@"任务2");
        
        dispatch_async(concurrentQueueA,^{
            NSLog(@"任务3");
        });
        
        NSLog(@"任务4");
    });
    
    NSLog(@"任务5");
}
// 执行结果 1 5 2 4 3

//--------------------- 测试2 ---------------------
- (void)DemoTwo{
    
    NSLog(@"任务1");
    
    // 任务2是异步，不会阻塞线程，继续向下执行，先打印 任务3
    dispatch_async(serialQueueA, ^{
        NSLog(@"任务2");
    });
    
    NSLog(@"任务3");
    
    // 因为任务4 和 任务2 在同一串行队列
    // 根据队列先进先出原则，任务4 必须等 任务2 执行后才能执行
    // 任务4 是同步任务，会阻塞线程
    // 只有执行完 任务4 才能继续向下执行打印5
    dispatch_sync(serialQueueA, ^{
        NSLog(@"任务4");
    });
    NSLog(@"任务5");
    
}
// 执行结果 1 3 2 4 5

//--------------------- 测试3 ---------------------
- (void)DemoThree{
    
    NSLog(@"任务1");
    
    // 任务2 是异步，则先打印 任务3
    dispatch_async(serialQueueA, ^{
        
        // 队列于队列之间是并发的关系
        // 就是说 任务2 和 任务4 是并发的
        
        //        // 可使用耗时操作可验证 4 5 2 的顺序
        //        for (int k = 0; k < 5000; k++) {
        //            NSLog(@"任务2的k值===%d",k);
        //        }
        
        NSLog(@"任务2");
    });
    
    NSLog(@"任务3");
    
    // 任务4 是同步，任务5要等待 任务4 执行完毕后才能执行
    // 任务5 必须在 任务4 后才能执行
    dispatch_sync(serialQueueB, ^{
        [NSThread sleepForTimeInterval:1.0];
        NSLog(@"任务4");
    });
    NSLog(@"任务5");
}
// 执行结果 1 3 2 4 5
// 实际存在多种情况 1 3  245 或 425 或 452

//--------------------- 测试4 ---------------------
- (void)DemoFour{
    
    NSLog(@"任务1");
    
    // dispatch_sync 阻塞线程：必须等待block返回，才能执行task3
    // 而当前主队列中正在被 任务1 执行，必须等待完成 任务3 完成后才能释放
    // 这就造成了 任务3 等待 block 完成返回
    // block 缺又要等待 任务3 的完成去释放主队列，进造成了相互等待的循环
    dispatch_sync(mainQueue, ^{
        NSLog(@"任务2");
    });
    
    NSLog(@"任务3");
}
// 执行结果：crash

//--------------------- 测试5 ---------------------
- (void)DemoFive{
    
    NSLog(@"任务1");
    
    dispatch_sync(serialQueueA, ^{
        NSLog(@"任务2");
    });
    
    NSLog(@"任务3");
}
// 执行结果：1 2 3

//--------------------- 测试6 ---------------------
- (void)DemoSix{
    
    NSLog(@"任务1");
    
    // 串行队列中追加的 任务3 和 串行队列中原有的 任务4 两者之间相互等待
    dispatch_async(serialQueueA, ^{
        
        NSLog(@"任务2");
        
        dispatch_sync(serialQueueA, ^{
            NSLog(@"任务3");
        });
        
        //        // 将 任务3 放置进区别于 serialQueueA 的队列，不会 crash
        //        // 这样就阻塞了当前队列 serialQueueA，依次顺序执行
        //        // 执行结果 1 5 2 3 4
        //        dispatch_sync(serialQueueB, ^{
        //            NSLog(@"任务3");
        //        });
        
        NSLog(@"任务4");
    });
    
    NSLog(@"任务5");
    
    // 任务2、任务4 和 任务3 在同一队列中执行，dispatch_sync 确定了 任务4 需要等待 任务3 完成后返回才能执行
    // 而 任务2 执行的时候已经占用了 当前队列serialQueueA，需要等到 任务4 完成后才能释放该队列
    // 这就造成了 任务3 等待 任务4 的完成；而 任务4 又要等待 任务3 的返回结果才能执行
    
}
// 执行结果：crash

//--------------------- 测试7 ---------------------
- (void)DemoSeven{
    
    // 异步
    dispatch_async(concurrentQueueA, ^{
        NSLog(@"任务1");
    });
    // 异步
    dispatch_async(concurrentQueueA, ^{
        NSLog(@"任务2");
    });
    // 同步
    dispatch_sync(concurrentQueueA, ^{
        NSLog(@"任务3");
    });
    
    // 主线程
    // ------------------
    NSLog(@"任务0");
    // ------------------
    
    
    // 异步
    dispatch_async(concurrentQueueA, ^{
        NSLog(@"任务4");
    });
    // 异步
    dispatch_async(concurrentQueueA, ^{
        NSLog(@"任务5");
    });
    // 同步
    dispatch_sync(concurrentQueueA, ^{
        NSLog(@"任务6");
    });
}

// 执行结果： 1 2 3 无序执行； 0 必定在中间 第4位 执行； 4 5 6 无序执行

@end

测试二：多线程是不安全的，使用不规范极易出现抢占公共资源的问题 

- (void)viewDidLoad {
    [super viewDidLoad];
    
    __block int a = 0;
    while (a < 4) {

        //  异步执行：会出现抢占资源问题
        //  极有可能在一瞬间存在多个子线程同时在执行 a++
        dispatch_async(dispatch_get_global_queue(0, 0), ^{
            NSLog(@"当前线程：%@",[NSThread currentThread]);
            a++;
        });
    }

    // 输出结果基本上可以说必定是 >= 4
    NSLog(@"验证猜想：%d",a);
}