什么是GCD

Grand Central Dispatch或者GCD，是一套低层API，提供了一种新的方法来进行并发程序编写。他们都允许程序将任务切分为多个单一任务然后提交至工作队列来并发地或者串行地执行。GCD比之NSOpertionQueue更底层更高效，并且它不是Cocoa框架的一部分。

除了代码的平行执行能力，GCD还提供高度集成的事件控制系统。可以设置句柄来响应文件描述符、mach ports（Mach port 用于 OS X上的进程间通讯）、进程、计时器、信号、用户生成事件。这些句柄通过GCD来并发执行。

GCD的API很大程度上基于block，当然，GCD也可以脱离block来使用，比如使用传统c机制提供函数指针和上下文指针。实践证明，当配合block使用时，GCD非常简单易用且能发挥其最大能力。

理解串行、并发及同步异步

串行和并发

串行和并发描述了任务之间执行的时机。任务如果是串行的，那么在同一时间只执行一个任务。并发的多个任务被执行的时候，可能是在同一时间。

同步和异步

同步和异步描述了一个函数相对于另一个函数何时执行完毕。同步的函数只有当它调用的任务执行完，才会返回。而异步函数，会立即返回。虽然它也命令任务执行完，但它并不等待任务执行完。如此，异步函数就不会阻塞当前线程。（这样说可能有些过于抽象了，个人理解的是，在同步的时候没有开启子线程的能力，而在异步的时候具备开启子线程的能力）。

队列

串行队列

1）使用dispatch_queue_create函数创建串行队列

dispatch_queue_t queue  = dispatch_queue_create（“队列名”，NULL）;
dispatch_queue_t queue  = dispatch_queue_create（“队列名”，DISPATCH_QUEUE_SERIAL）;

两者等效.
2)使用主队列（在主队列中的任务，都会放到主线程中执行，它也是唯一一个允许更新UI的队列，所以要是开启子线程的时候要更新UI的情况下一定要用主队列进行更新）

dispatch_queue_t queue = dispatch_get_main_queue();

并发队列（GCD默认已经提供了全局的并发队列）

1）获得全局队列

dispatch_queue_t queue = dispatch_get_global_queue(dispatch_queue_priority,unsigned long flags)；
        前一个参数是优先级，有以下几种：
        DISPATCH_QUEUE_PRIORITY_HIGH 2//高
        DISPATCH_QUEUE_PRIORITY_DEFAULT 0//默认
        DISPATCH_QUEUE_PRIORITY_LOW （-2）//低
        DISPATCH_QUEUE_PRIORITY_BACKGROUND INT16_MN//后台

2）自定义并发队列

dispatch_queue_t queue  = dispatch_queue_create（“队列名”，DISPATCH_QUEUE_CONCURRENT）;

在开发中基本上就是通过dispatch_async和dispatch_sync 分别配合着上面的三种队列使用，但是更多的情况下基本上就是dispatch_async和全局队列配合使用，并用主线程中更新UI。

dispatch_async

1）全局队列

    //在这里获取全局队列
    dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
    dispatch_async(queue, ^{
        NSLog(@"task1%@",[NSThread currentThread]);
    });
    dispatch_async(queue, ^{
        NSLog(@"task2%@",[NSThread currentThread]);
    });
    dispatch_async(queue, ^{
        NSLog(@"task3%@",[NSThread currentThread]);
    });

打印结果

2016-07-31 21:08:51.114 GCD[81282:8816505] task2<NSThread: 0x7fb36b900080>{number = 2, name = (null)}
2016-07-31 21:08:51.114 GCD[81282:8816516] task3<NSThread: 0x7fb369ff59a0>{number = 3, name = (null)}
2016-07-31 21:08:51.114 GCD[81282:8816512] task1<NSThread: 0x7fb369e2bba0>{number = 4, name = (null)}

可以看出GCD开启了子线程并且并发执行
2）主队列

    //在这里获取主队列
    dispatch_queue_t queue = dispatch_get_main_queue();
    dispatch_async(queue, ^{
        NSLog(@"task1%@",[NSThread currentThread]);
    });
    dispatch_async(queue, ^{
        NSLog(@"task2%@",[NSThread currentThread]);
    });
    dispatch_async(queue, ^{
        NSLog(@"task3%@",[NSThread currentThread]);
    });

打印结果

2016-07-31 21:14:37.452 GCD[81293:8820034] task1<NSThread: 0x7ffb7a000720>{number = 1, name = main}
2016-07-31 21:14:37.452 GCD[81293:8820034] task2<NSThread: 0x7ffb7a000720>{number = 1, name = main}
2016-07-31 21:14:37.452 GCD[81293:8820034] task3<NSThread: 0x7ffb7a000720>{number = 1, name = main}

可以看出来虽然用了dispatch_async但是并没有开启子线程来执行任务，这是因为队列的性质决定的，所以在用主队列的时候要注意。

dispatch_sync

1）全局队列

    //在这里获取全局队列
    dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
    dispatch_sync(queue, ^{
        NSLog(@"task1%@",[NSThread currentThread]);
    });
    dispatch_sync(queue, ^{
        NSLog(@"task2%@",[NSThread currentThread]);
    });
    dispatch_sync(queue, ^{
        NSLog(@"task3%@",[NSThread currentThread]);
    });

打印结果

2016-07-31 21:19:06.993 GCD[81311:8822954] task1<NSThread: 0x7f9208e04fe0>{number = 1, name = main}
2016-07-31 21:19:06.994 GCD[81311:8822954] task2<NSThread: 0x7f9208e04fe0>{number = 1, name = main}
2016-07-31 21:19:06.994 GCD[81311:8822954] task3<NSThread: 0x7f9208e04fe0>{number = 1, name = main}

可以看出来dispatch_sync中虽然用的是全局队列，但是并没有并发，因为dispatch_sync没有开启子线程的能力，只能在主线程中串行执行任务。
2）主队列

    //在这里获取主队列
    dispatch_queue_t queue = dispatch_get_main_queue();
    dispatch_sync(queue, ^{
        NSLog(@"task1%@",[NSThread currentThread]);
    });
    dispatch_sync(queue, ^{
        NSLog(@"task2%@",[NSThread currentThread]);
    });
    dispatch_sync(queue, ^{
        NSLog(@"task3%@",[NSThread currentThread]);
    });

这样是不会有打印结果的，因为发生了死锁，在这个过程中，主线等着GCD运行完成后继续运行而GCD等待着主线运行完成后继续运行，产生了死锁，所以不能这样使用。

dispatch_after

  //在这里只有用主队列有意义
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(3 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        NSLog(@"task1%@",[NSThread currentThread]);
    });
    NSLog(@"主线");

打印结果

2016-07-31 21:37:14.292 GCD[81346:8829855] 主线
2016-07-31 21:37:17.292 GCD[81346:8829855] task1<NSThread: 0x7fee08604ea0>{number = 1, name = main}

可以看出在block中的任务被延迟了3秒钟执行。但是这个是有问题的，这里只是延时提交了block，并不是延时后立即执行。所以dispatch_after不能精准的控制运行状态。

dispatch_once

dispatch_once是一种线程安全的方式，执行只执行一次代码块保证多线程安全。

   + (instancetype)sharedManager
    {
        static ToolManager *sharedPhotoManager = nil;
        static dispatch_once_t onceToken;
        dispatch_once(&onceToken, ^{
            sharedManager = [[ToolManager alloc] init];
        });
        return sharedPhotoManager;
    }

dispatch_group

有的时候我们要在完成一些任务的前提下再去完成后面的任务，这个时候就要用到dispatch_group。
1）同步的方式（dispatch_group_wait）(这个方法会阻塞线程，后面的代码要等到wait完成后运行)

    //由于我们用了同步的方式dispatch_group_wait，它会阻塞当前线程，所以我们在整个方法外面套上了dispatch_async，使它在后台执行而不会阻塞主线程。
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0), ^{
        dispatch_group_t downloadGroup = dispatch_group_create();
        
        for (NSInteger i = 0; i < 3; i++) {
            //dispatch_group_enter告知group，一个任务开始了。我们需要将dispatch_group_enter与dispatch_group_leave配对，否则我们会遇到莫名其妙的崩溃。
            dispatch_group_enter(downloadGroup);
            
            sleep(2);
            NSLog(@"task%ld",i);
            //dispatch_group_leave告知group，此任务执行完毕，要注意与dispatch_group_enter配对。
            dispatch_group_leave(downloadGroup);
            
        }
        //dispatch_group_wait等待所有任务完成或者超时，在此处我们设置等待时间为永远DISPATCH_TIME_FOREVER
        dispatch_group_wait(downloadGroup, DISPATCH_TIME_FOREVER);
        //当以上所有任务执行完后，我们在主队列调用任务完成的block。
        dispatch_async(dispatch_get_main_queue(), ^{
            NSLog(@"主线");
        });
    });

在这里有个问题，就是说如果我们将其中的超时时间设置成5秒，但是其中的一个任务要延时10秒，那么这个任务不会因为这个超时时间到了停止，还会继续完成任务，但是不会等到这个任务完成后再去执行dispatch_group_wait后面的代码。

2）异步的方式（dispatch_group_notify）（不会阻塞线程，后面的代码会执行，不用等待这些任务和notify）

    dispatch_group_t downloadGroup = dispatch_group_create();
    
    dispatch_group_async(downloadGroup, dispatch_get_global_queue(0, 0), ^{
        NSLog(@"task1%@",[NSThread currentThread]);
    });
    dispatch_group_async(downloadGroup, dispatch_get_global_queue(0, 0), ^{
         NSLog(@"task2%@",[NSThread currentThread]);
    });
    dispatch_group_async(downloadGroup, dispatch_get_global_queue(0, 0), ^{
        NSLog(@"task3%@",[NSThread currentThread]);
    });
    dispatch_group_notify(downloadGroup, dispatch_get_main_queue(), ^{
        NSLog(@"主线");
    });

其中还涉及到了dispatch_group_enter和dispatch_group_leave，我理解这个就是将任务添加到队列中，并且他们要成对的出现。他们将任务添加到当前的线程中，也就是说如果任务都没有开启子线程，那么添加进去的就是在当前的线程中串行执行，如果任务开启了子线程，那么添加进去的就是在相对的子线程可能串行，可能并行（这个要看队列的性质）

    dispatch_group_enter(group);
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        dispatch_group_leave(group);
    });

  dispatch_group_async(group, dispatch_get_global_queue(0, 0), ^{
        
    });

这两种的性质是一样的。

dispatch_apply

dispatch_apply(3, dispatch_get_global_queue(0, 0), ^(size_t i) {
        sleep(2);
        NSLog(@"任务组%d完成%@",i,[NSThread currentThread]);
    });

打印结果

2016-07-31 23:54:15.378 GCD[81633:8885238] 任务组0完成<NSThread: 0x7fbaf3704c10>{number = 1, name = main}
2016-07-31 23:54:15.381 GCD[81633:8885283] 任务组2完成<NSThread: 0x7fbaf3623960>{number = 2, name = (null)}
2016-07-31 23:54:15.381 GCD[81633:8885275] 任务组1完成<NSThread: 0x7fbaf3526f50>{number = 3, name = (null)}

dispatch_apply和for循环都是串行的，当dispatch_apply中的工作全都完成后才会返回，可以看出来里面的是并发执行的所以返回的先后顺序是不能确定的，不能和for循环一样用。

dispatch_suspend和dispatch_resume

 dispatch_queue_t queue = dispatch_queue_create("me.tutuge.test.gcd", DISPATCH_QUEUE_SERIAL);
    //提交第一个block，延时5秒打印。
    dispatch_async(queue, ^{
        
        [NSThread sleepForTimeInterval:5];
        
        NSLog(@"After 5 seconds...");
    });
    //提交第二个block，也是延时5秒打印
    dispatch_async(queue, ^{
        
        [NSThread sleepForTimeInterval:5];
        
        NSLog(@"After 5 seconds again...");
    });
    //延时一秒
    
    NSLog(@"sleep 1 second...");
    [NSThread sleepForTimeInterval:1];
    //挂起队列
    
    NSLog(@"suspend...");
    dispatch_suspend(queue);
    //延时10秒
    
    NSLog(@"sleep 10 second...");
    [NSThread sleepForTimeInterval:10];
    //恢复队列
    dispatch_resume(queue);
    
    NSLog(@"resume...");

打印结果

2016-08-01 13:46:29.817 GCD[81925:8937362] sleep 1 second...
2016-08-01 13:46:30.818 GCD[81925:8937362] suspend...
2016-08-01 13:46:30.819 GCD[81925:8937362] sleep 10 second...
2016-08-01 13:46:34.819 GCD[81925:8937412] After 5 seconds...
2016-08-01 13:46:40.819 GCD[81925:8937362] resume...
2016-08-01 13:46:45.820 GCD[81925:8937412] After 5 seconds again...

这两个就是将任务挂起和恢复的功能，从结果可以看出来当队列挂起后第一个block还是在运行，并且能够正常的输出。可知，dispatch_suspend并不会停止正在运行的block，只会暂停后续的block的执行。

dispatch_barrier_async和dispatch_barrier_sync

dispatch_queue_t queue = dispatch_queue_create("msdf",  DISPATCH_QUEUE_CONCURRENT);
    dispatch_async(queue, ^{
        sleep(5);
        NSLog(@"task1");
    });
    dispatch_async(queue, ^{
        sleep(5);
        NSLog(@"task2");
    });
    dispatch_barrier_async(queue, ^{
        sleep(3);
        NSLog(@"barrier");
    });
    dispatch_async(queue, ^{
        sleep(2);
        NSLog(@"task3");
    });
    dispatch_async(queue, ^{
        sleep(2);
        NSLog(@"task4");
    });

dispatch_barrier_async的作用就是向某个队列插入一个block，当目前正在执行的block运行完成后，阻塞这个block后面添加的block，只运行这个block直到完成，然后再继续后续的任务。
dispatch_barrier\(a)sync只在自己创建的并发队列上有效，在全局(Global)并发队列、串行队列上，效果跟dispatch_(a)sync效果一样。
接下来就来看看dispatch_barrier_sync和dispatch_barrier_async的相同点与不同点
相同点：两者只有前面的任务执行完成之后并且执行完成barrier中的代码后才能执行后面的任务。
            两者都能够阻塞当前的线程
不同点：dispatch_barrier_async在阻塞当前线程时，不需要等待barrier中的代码完成后再运行后面的非任务代码；
         dispatch_barrier_sync在阻塞当前线程时，需要等待barrier中的代码完成后再运行后面的非任务代码。

dispatch_semaphore

信号量是一个整形值并且具有一个初始计数值，并且支持两个操作：信号通知和等待。当一个信号量被信号通知，其计数会被增加。当一个线程在一个信号量上等待时，线程会被阻塞（如果有必要的话），直至计数器大于零，然后线程会减少这个计数。

在GCD中有三个函数是semaphore的操作，分别是：
　　dispatch_semaphore_create　　　创建一个semaphore
　　dispatch_semaphore_signal　　　发送一个信号
　　dispatch_semaphore_wait　　　　等待信号
　　简单的介绍一下这三个函数，第一个函数有一个整形的参数，我们可以理解为信号的总量，dispatch_semaphore_signal是发送一个信号，自然会让信号总量加1，dispatch_semaphore_wait等待信号，当信号总量少于0的时候就会一直等待，否则就可以正常的执行，并让信号总量-1，根据这样的原理，我们便可以快速的创建一个并发控制来同步任务和有限资源访问控制。

    dispatch_group_t group = dispatch_group_create();   
    dispatch_semaphore_t semaphore = dispatch_semaphore_create(10);   
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);   
    for (int i = 0; i < 100; i++)   
    {   
        dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);   
        dispatch_group_async(group, queue, ^{   
            NSLog(@"%i",i);   
            sleep(2);   
            dispatch_semaphore_signal(semaphore);   
        });   
    }   
    dispatch_group_wait(group, DISPATCH_TIME_FOREVER);

简单的介绍一下这一段代码，创建了一个初使值为10的semaphore，每一次for循环都会创建一个新的线程，线程结束的时候会发送一个信号，线程创建之前会信号等待，所以当同时创建了10个线程之后，for循环就会阻塞，等待有线程结束之后会增加一个信号才继续执行，如此就形成了对并发的控制，如上就是一个并发数为10的一个线程队列。

dispatch_get_current_queue

现在这个方法已经被不建议使用了，但是就像在此强调一下，这个方法用不好会造成死锁，在此不再赘余。