首先来看两个概念: 任务和队列

任务(什么block，函数，以及随便的代码片段都可以称为一个任务)
任务分为同步任务和异步任务：同步任务会阻塞当前线程(其实这个任务也就是block中的内容)，等block中的任务执行完成之后，当前线程才会继续往下执行；异步任务不会阻塞当前线程，也就是不需要等block中的任务执行完成，当前线程就能直接往下执行。
队列(任务调度的规则)
队列分为串行队列和并行队列:串行队列中，GCD会按照先进先出的原则，顺序执行放进来的任务；并行队列中，GCD其实也是按照先进先出的原则，只是每个任务可能被放进了不同的线程，因为速度非常快，所以给我们的感觉像是所有的任务同时执行

两个常用的队列

dispatch_get_global_queue: 全局并发队列，可以同时提供多个线程执行任务。
dispatch_get_main_queue: 串行主队列，只能提供一个主线程来执行任务。

下面用实例来分析一下常见的死锁问题。

1.同步主队列死锁

- (void)gcdTest1 {
    NSLog(@"1 - %@",[NSThread currentThread]); //1
    dispatch_sync(dispatch_get_main_queue(), ^{
        NSLog(@"2 - %@",[NSThread currentThread]); //2
    });
    NSLog(@"3 － %@",[NSThread currentThread]); //3
    
    //打印：1
 /*
    解释：dispatch_sync阻塞了当前线程，跑去执行任务2，
而任务2又是被放到主队列里面，也就是要在主线程中执行了，
但是它是放在了任务3的后面(不要以为任务2的代码写在了任务3的前面，任务2在队列中就排在了任务3的前面)。
由于主队列是一个串行队列，任务2需要等任务3执行完之后，才能被执行，而此时线程已经在任务3之前被阻塞住了，
所以任务3不可能被执行，所以任务2也不可能被执行
     */
}

2.同步全局并行队列

- (void)gcdTest2 {
    NSLog(@"1 - %@",[NSThread currentThread]); //1
    dispatch_sync(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        NSLog(@"2 - %@",[NSThread currentThread]); //2 (通过打印可以发现，任务2也是放在主线程中执行的，这也就说明了全局队列是可以拿主线程来执行相应任务的)
    });
    NSLog(@"3 － %@",[NSThread currentThread]); //3
    
    //打印：1，2，3
    /*
       解释：首先dispatch_sync阻塞当前线程,跑去执行任务2,
任务2是被放到dispatch_get_global_queue这个并行队列里面， 
而任务3是在主队列里面，也就是说这两个任务根本就不在同一个队列，
就不存在一个先后顺序的问题，所以三个任务都会被执行
     */
   }

3.同步自定义串行队列

- (void)gcdTest3 {
    NSLog(@"1 － %@",[NSThread currentThread]); //1
    dispatch_sync(dispatch_queue_create("myQueue", DISPATCH_QUEUE_SERIAL), ^{
        NSLog(@"2 - %@",[NSThread currentThread]); //2
    });
    NSLog(@"3 - %@",[NSThread currentThread]);//3
    
    //打印：1，2，3
    /*
      解释：同上。也就是任务2和任务3两个任务处于不同的队列，所以没有影响，都会被执行。
     */
  }

4.异步主队列

- (void)gcdTest4 {
    NSLog(@"1 - %@",[NSThread currentThread]); //1
    dispatch_async(dispatch_get_main_queue(), ^{
        NSLog(@"2 - %@",[NSThread currentThread]);//2 (这里打印的还是主线程，说明异步并不代表要开辟新的线程，)
    });
    NSLog(@"3 - %@",[NSThread currentThread]);//3
    
    //打印：1，3，2
/*
  解释：dispatch_async是一个异步任务，不会阻塞当前线程，
所以3可以执行，dispatch_get_main_queue是一个串行队列，所以任务2是排在任务3的后面
*/    
}

5.异步全局队列

- (void)gcdTest5 {
    
        NSLog(@"1 - %@",[NSThread currentThread]); //1
        dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
            NSLog(@"2 - %@",[NSThread currentThread]); //2
        });
        NSLog(@"3 - %@",[NSThread currentThread]); //3
    //打印: 1,3,2
    /*
        解释：这个跟上面那个的区别是：上面那个任务2是放到主队列里面的，
肯定是排在任务3的后面，所以打印的结果是1，3，2.
        但是这个任务2是放在一个全局队列里面，而任务3是放到主队列里面，
按理说任务2和任务3是可以并行的，
也就是说任务3和任务2的执行顺序可能不确定，但是我们通过打印发现，
在执行任务2的时候开辟了新的线程，而开辟新的线程需要额外的时间，所以任务2一般都会排在任务3的后面。
     */
    
}

6.异步并行队列2

- (void)gcdTest6 {
    NSLog(@"1 － %@",[NSThread currentThread]); //1
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        NSLog(@"2 - %@",[NSThread currentThread]); //2
    });
    for (int i = 0; i<100; i++) { //3
        NSLog(@"3 - %@",[NSThread currentThread]);
    }
    //打印:任务2穿插在任务3循环中间
    /*
        解释：上面刚刚说过，任务2会开辟新的线程，需要额外的时间， 
但是任务3是一个大循环，需要更多的时间。所以从理论上说，任务2和任务3的执行顺序还是不确定的
     */
    
   }

7.交叉分析

- (void)gcdTest7 {
    NSLog(@"1"); // 任务1
    dispatch_async(dispatch_get_global_queue(0, 0), ^{ //block1
        NSLog(@"2 - %@",[NSThread currentThread]); // 任务2
        dispatch_sync(dispatch_get_main_queue(), ^{
            NSLog(@"3"); // 任务3
        });
        NSLog(@"4"); // 任务4
    });
    NSLog(@"5"); // 任务5
    //打印：1,5,2,3,4
    /*
        解释:任务1执行完之后，dispatch_async异步去执行另外的任务，不会阻塞当前线程，
所以任务5接着被执行，接着任务2被执行，dispatch_sync又阻塞了block1中的线程去执行任务3，
而任务3是放在主队列中的，跟任务4不是同一个队列，所以任务3执行完了之后，
任务4也被执行了，所以打印的结果是: 1,5,2,3,4
     */
}

- (void)gcdTest8 {
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        NSLog(@"1 - %@",[NSThread currentThread]); // 任务1
        dispatch_sync(dispatch_get_main_queue(), ^{
            NSLog(@"2 - %@",[NSThread currentThread]); // 任务2
        });
        NSLog(@"3"); // 任务3
    });
    NSLog(@"4"); // 任务4
    while (1) {
    }
    NSLog(@"5"); // 任务5
   
    //打印结果:4,1
    /*
        解释:dispatch_async是一个异步任务，不会阻塞当前线程，
所以任务4会执行，然后进入block，执行任务1，
接着dispatch_sync会阻塞block中线程，开始执行任务2，
而任务2是放到主队列中的，排在任务5的后面，
而任务5又在死循环的后面，不可能被执行，所以任务2不会被执行，从而3也不会被完成,所以打印结果是4,1。
     */
    
}