* author：conowen@大钟                                                                                                                          
 * E-mail：conowen@hotmail.com      

GCD

在是iOS中，开发者通过GCD这个API来进行线程的切换，并且通过设置的dispatch_queue_t来来控制任务队列是并行还是串行。任务队列由一个或多个任务组成，当这些任务要开始执行时，系统会分别把他们分配到某个线程上去执行。

串行队列、并行队列

GCD编程中，创建一个队列代码如下

dispatch_queue_t queue_t_concurrent = dispatch_queue_create("com.conowen.concurrent", DISPATCH_QUEUE_CONCURRENT);//concurrent  
dispatch_queue_t queue_t_serial = dispatch_queue_create("com.conowen.serial", DISPATCH_QUEUE_SERIAL);//serial  

DISPATCH_QUEUE_SERIAL的值为NULL
除了自定义队列，系统还有常用的两个队列。

• 主队列： dispatch_get_main_queue，一切的UI操作务必在主队列中操作。
• 全局并行队列： dispatch_get_global_queue。

如果有以下任务：[任务A，任务B，任务C，任务D]
按照顺序放在串行队列中运行，那么最终得到结果的顺序也是ABCD的顺序，假若放在并行队列中运行，结果的顺序是随机的。

//异步切换到主线程
dispatch_async(dispatch_get_main_queue(), ^{ //主串行队列
    //task
});
//同步切换到主线程
dispatch_sync(dispatch_get_main_queue(), ^{  //主串行队列
    //task
});
//异步切换到子线程
dispatch_async(dispatch_get_global_queue(0, 0), ^{  //并行队列
    //task
});
//同步切换到子线程
dispatch_sync(dispatch_get_global_queue(0, 0), ^{  //并行队列
    //task
});

简单来说，GCD是对线程的一个抽象，开发者无需关心线程，关心任务的队列即可。GCD会自动管理线程的生命周期（创建线程、调度任务、销毁线程）。

async、sync

async

使用dispatch_async 调用一个block，如：dispatch_async(myQueue,myBlock);这个myBlock会被放到myQueue队列的队尾等待执行，这时候，这个myBlock任务并没有串行与并行一说，如果myQueue是并行，那么这个myBlock任务就是并行运行，如果myQueue是串行队列，那么这个MyBlock就是串行运行，但是dispatch_async会马上结束并且返回。

dispatch_async(myQueue, ^{   
  //do something
});

sync

使用dispatch_sync ，如dispatch_sync(myQueue,myBlock);，同样也是把myBlock任务放到myQueue上面执行，但是dispatch_sync会等待这个myBlock执行完毕才会结束返回，也就是说，它会一直阻塞当前dispatch_sync所在的线程直到myQueue队列中myBlock任务执行完，返回。

需要记住一点就是，GCD的sync会阻塞当前线程，等待Block的任务结束返回。

dispatch_barrier

GCD中除了提供上述两种dispatchAPI以外，还提供了Dispatch_barrier系统的API，俗称栅栏,使用dispatch_barrier_sync()、dispatch_barrier_async()。就相当于一个限流的栅栏。
dispatch_barrier之前添加的block任务先执行才轮到dispatch_barrier之后添加的block任务执行。

- (void)barrier
{
    NSLog(@"add task1 block");
    dispatch_async(self.concurrentQueue, ^{
        // task1
        sleep(1.0);
        NSLog(@"task1");
    });
    NSLog(@"add task2 block");
    dispatch_async(self.concurrentQueue, ^{
        // task2
        sleep(1.0);
        NSLog(@"task2");
    });
    NSLog(@"add barrier async task");
    dispatch_barrier_async(self.concurrentQueue, ^{
        // barriertask
        sleep(1.0);
        NSLog(@"barrier async task");
    });
    NSLog(@"add task3 block");
    dispatch_async(self.concurrentQueue, ^{
        // task3
        sleep(1.0);
        NSLog(@"task3");
    });
}

输入结果就是

2021-05-29 17:54:12.989952+0800 Test[84911:9673182] add task1 block
2021-05-29 17:54:12.990075+0800 Test[84911:9673182] add task2 block
2021-05-29 17:54:12.990170+0800 Test[84911:9673182] add barrier async task
2021-05-29 17:54:12.990279+0800 Test[84911:9673182] add task3 block
2021-05-29 17:54:13.993560+0800 Test[84911:9673237] task1
2021-05-29 17:54:13.993560+0800 Test[84911:9673235] task2
2021-05-29 17:54:14.996732+0800 Test[84911:9673235] barrier async task
2021-05-29 17:54:15.997432+0800 Test[84911:9673235] task3

如果是dispatch_barrier_async，就要等待barrier中的block完成后，才能继续后面的block任务添加。
输出就变成

2021-05-29 17:55:44.060454+0800 Test[84973:9674991] add task1 block
2021-05-29 17:55:44.060686+0800 Test[84973:9674991] add task2 block
2021-05-29 17:55:44.060776+0800 Test[84973:9674991] add barrier async task
2021-05-29 17:55:45.064232+0800 Test[84973:9675080] task1
2021-05-29 17:55:45.064232+0800 Test[84973:9675074] task2
2021-05-29 17:55:46.065319+0800 Test[84973:9674991] barrier async task
2021-05-29 17:55:46.065710+0800 Test[84973:9674991] add task3 block
2021-05-29 17:55:47.068985+0800 Test[84973:9675075] task3

经典的死锁问题

- (void)viewDidLoad
{
    [super viewDidLoad];
    NSLog(@"1");
    dispatch_sync(dispatch_get_main_queue(), ^{
        NSLog(@"2");
    });
    NSLog(@"3");
}

出现死锁的两个关键前提就是：
1、在同一个串行队列中
2、同一个线程中。

因为^{NSLog(@"2");}这个Block放在dispatch_get_main_queue()主串行队列中执行，但是由于是串行队列，Block并不会立马就执行，（要排队）。这时候dispatch_sync阻塞主线程，等待main_queue中的Block执行完毕，但是由于主线程被阻塞了，Block中的代码永远不会执行，出现了互相等待的情况，这样就导致的死锁。

但是如果是以下代码就不会导致死锁

dispatch_queue_t queue_t_concurrent = dispatch_queue_create("com.conowen.concurrent", DISPATCH_QUEUE_CONCURRENT);//concurrent
    dispatch_async(queue_t_concurrent, ^{
        dispatch_sync(queue_t_concurrent, ^{
            NSLog(@"2");
        });
    });

因为Block 在并行队列中（不用在队列中排队），会被立刻执行，然后返回结果，所以dispatch_sync也不会等待出现一直等待Block结果的状态，这时候不会出现死锁情况。

所以苹果废弃掉了dispatch_get_current_queue方法，就是怕会出现以下代码导致死锁。

dispatch_queue_t queue_t_serial = dispatch_queue_create("com.conowen.serial", DISPATCH_QUEUE_SERIAL);//serial  
    dispatch_async(queue_t_serial, ^{
        dispatch_sync(dispatch_get_current_queue(), ^{
            NSLog(@"0");
        });
    });