GCD的基本概念已经很熟悉了：线程调度器。而作为一名开发者，只需要将想执行的任务，追加到适当的queue当中。
所以先介绍一下这个“queue”：
有两种类型的队列
1，串行队列：其中追加的任务是串行处理的，main_queue 就是一个串行队列
2，并行队列：其中追加的任务是并行处理的。 执行顺序是不确定的。
开发中，我们可以获取系统提供的队列，也可以自己创建队列
系统提供了五中队列：
一种是，Main Queue 是一种串行队列，在主线程中执行，可以通过dispatch_get_main_queue()获取
其余四中是：优先级分别为high，default，low，background的并行队列，可以通过dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH,0);
这里第一个参数是优先级，第二个参数是0，这里是官方文档说的哈！
第二个参数的解释自己创建队列：
dispatch_queue_t queue = dispatch_queue_create("name",NULL);
这个函数，返回的是一个dispatch_queue_t对象（也就是一个队列），第一个参数为队列名，第二个参数为类型，如果传（NULL或者DISPATCH_QUEUE_SERIAL）则创建串行队列，如果传DISPATCH_QUEUE_CONCURRENT，则创建并行队列。
好了，我们知道有两种方式可以创建队列，现在要将任务，追加到队列中。系统提供了两种方式：dispatch_sync,和dispatch_async(),很多人包括我自己在刚接触的时候，就被这两个函数加上两种不同的队列弄的晕转向。
1.dispatch_sync(queue,^{});
这个函数的意思是：将block中的任务，追加到queue中，追加这个动作，是同步的，就意味着，要阻塞当前线程。用这个函数，在block结束之前，该函数不会返回。如下代码：
dispatch_queue_t serialQueue =dispatch_queue_create("com.GCDTest.MySeialQueue", DISPATCH_QUEUE_SERIAL);//创建一个串行队列
dispatch_sync(serialQueue, ^{//将block追加到串行队列中
NSLog(@"1");
});//使用sync，当前线程，会等待sync函数执行完block的内容，并返回，才会继续接下来的任务。所以这里不管是用串行队列还是并行队列都不会开启多线程，可以在demo中打印一下thread试试
NSLog(@"2");
2，dispatch_async
这个函数是用异步的方式将block追加到队列中
dispatch_queue_t currentQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);//创建一个并行队列
dispatch_async(currentQueue, ^{//以异步的方式添加到队列中
NSLog(@"4");
});//当前线程不会等带async返回，就会执行下面的任务
NSLog(@"6");
所以现在考虑几种情况
1，用async将n个block添加到一个串行队列，那么这n个block会根据添加的顺序，在队列中顺序执行，并且会开启新的线程，主线程和当前线程并发执行。
2，用sync将n个block添加到一个串行队列，那么这n个block会根据添加的顺序，在队列中顺序执行，但是不会开启新的线程，会在主线程中执行这些block。
3，用async将n个block添加到一个并行队列，那么，就会开启n个线程，来并发执行这些block，执行顺序是不一定的。
4，用sync将n个block添加到一个并行队列，那么，和情况2相同，因为sync是同步函数，里面的内容没有执行完，不会返回，当前线程要在这个函数返回之后，才会继续下面的内容。
5，用sync将一个block添加到主队列中，那么，会引起线程死锁。主线程在等待sync中的函数执行完成，而sync在等待主线程执行block，所以会死锁。
dispatch_set_target_queue
该函数可以用来变更生成的dispatch_queue的优先级
dispatch_queue_t currentQueue1 = dispatch_queue_create("456", DISPATCH_QUEUE_CONCURRENT);
dispatch_queue_t currentQueue2 = dispatch_queue_create("789", DISPATCH_QUEUE_CONCURRENT);
dispatch_queue_t curentQueuelow = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_BACKGROUND, 0);
dispatch_set_target_queue(currentQueue1, curentQueuelow);//将queue1的优先级设为与curentQueuelow相同，也就是最低
dispatch_async(currentQueue1, ^{
NSLog(@"2");
});
dispatch_async(currentQueue2, ^{
NSLog(@"3");
});则会先输出3，再输出2，可以在demo中进行调试
dispatch_after
//不是在指定时间后处理block，而是在指定时间将block追加queue；
dispatch_time_t time = dispatch_time(DISPATCH_TIME_NOW, 3 * NSEC_PER_SEC);//第一个参数表示现在的时间，第二个参数表示指定的秒单位时间后的时间 数值 *NSEC_PER_SEC 得到单位为秒的数值，
dispatch_after(time, dispatch_get_main_queue(), ^{
NSLog(@"1");
});//3秒后将此block追加到mainqueue
NSLog(@"2");
NSLog(@"3");
dispatch_group
用于某个线程的操作，必须要在一些线程结束之后才能进行。还是直接上代码吧
dispatch_queue_t queue1 = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);//创建一个并行队列
dispatch_group_t group = dispatch_group_create();//创建一个group
dispatch_group_async(group, queue1, ^{
NSLog(@"1");
});//往group中添加队列，和队列中的block
dispatch_group_async(group, queue1, ^{
NSLog(@"2");
});
在最后，我们判断group中的任务是全部都执行完了呢
dispatch_time_t time = dispatch_time(DISPATCH_TIME_NOW, DISPATCH_TIME_FOREVER);
long resutl = dispatch_group_wait(group,time );//这里会等待group执行，如果执行完，返回0，time是我们要等待的时间
if (!resutl) {
NSLog(@"6");执行完之后的操作
}
还有一种方式：dispatch_group_notify(group, dispatch_get_main_queue(), ^{
NSLog(@"5");在group中追加的任务全部结束时，会掉用这里
});
dispatch_barrier_async
//在文件写取时，使用串行队列可避免数据竞争的问题，但是多个并行队列读取文件，并不会有什么问题.dispatch_barrier_async,会等待追加到concurrent queue 上的并行执行的处理全部结束之后，再将指定的处理，加到queue中。并且，这个函数操做完之后，再恢复。
dispatch_async(queue, ^{
NSLog(@"1");
});
dispatch_async(queue, ^{
NSLog(@"2");
});
dispatch_barrier_async(queue, ^{
NSLog(@"here");
});
dispatch_async(queue, ^{
NSLog(@"3");
});
这里打印会看到，here 肯定在1，2的后面，3 的前面.并且需要注意的是，这里添加的队列，只能是自定义的，不能是系统的，不然就没有这个作用了。
dispatch_apply
该函数，按照指定的次数，将block追加到指定的queue中，并等待全部执行结束。
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_apply(10, queue, ^(size_t index) {//第一个参数是重复次数，第二个参数是追加对象，第三个参数，追加的任务
//这个函数与dispatch_sync相同，会等待处理执行的结束，因此推荐的dispatch_async中非同步执行
NSLog(@"%zu",index);
});
NSLog(@"10");
dispatch_suspend/dispatch_resume
//有时希望不执行已经追加的处理,不过这类需求我还没有遇到过，资质尚浅，不过可以测试一下，看是否能挂起，（这里挂起对已经执行的block没有影响，只是暂停对后面block的调度）
dispatch_queue_t queue = dispatch_queue_create("1", DISPATCH_QUEUE_SERIAL);
dispatch_async(queue, ^{
NSLog(@"1");
dispatch_sync(dispatch_get_main_queue(), ^{
dispatch_suspend(queue);
[NSThread sleepForTimeInterval:2];
NSLog(@"3");
dispatch_resume(queue);
});
});
dispatch_async(queue, ^{
NSLog(@"2");
});
这里打印1的时候，会挂起，不会调用打印2 的block，但是当前block不受影响
dispatch semaphore
它是持有计数的信号，计数为0是，则等待，计数为1时，则减一执行。还是根据代码来看一下吧
dispatch_semaphore_t sema = dispatch_semaphore_create(1);//将计数值初始化为1，创建对象sema。
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_async(queue, ^{
dispatch_semaphore_wait(sema, DISPATCH_TIME_FOREVER);
//dispatch_semaphore_wait(sema, DISPATCH_TIME_FOREVER);//等待sema的技术值大于或等于1，当技术值大于或等于1，对该技术进行减去并从这个函数返回，返回值和dispatch_group_wait返回值相同，
NSLog(@"1");
dispatch_semaphore_signal(sema);//处理结束，通过此函数来加1
});
dispatch_async(queue, ^{
dispatch_semaphore_wait(sema, DISPATCH_TIME_FOREVER);
[NSThread sleepForTimeInterval:1];
NSLog(@"2");
dispatch_semaphore_signal(sema);
});
该方法可以通过一个计数，来达到串行队列，或者dispatch_barrier_async的排他效果。