iOS多线程之GCD学习笔记

前言

GCD是iOS开发中十分重要的多线程方案之一，通过对大神文章的学习，此篇文章为代码的练习和一部分自己学习的总结和记录。

原文章链接：https://www.jianshu.com/p/2d57c72016c6

简介

GCD的全称是Grand Central Dispatch，可译为“牛逼的中枢调度器”，纯C语言，提供了非常多强大的函数。

GCD是苹果公司为多核的并行运算提出的解决方案
GCD会自动利用更多的CPU内核（比如双核、四核）
GCD会自动管理线程的生命周期（创建线程、调度任务、销毁线程）

GCD任务和队列

GCD中两个核心的概念：任务和队列
任务：就是要执行的操作，在GCD中执行操作的代码块是写在block中的。任务有两种派发方式：同步派发和异步派发。

同步派发和异步派发的区别就是是否会阻塞当前线程，同步派发的任务在当前线程执行，并使当前线程等待派发的任务执行完成才能继续执行。异步派发的任务在其他线程执行，不会阻塞当前线程。。当然还有一条优先级更高的规则，凡是派发到主队列的任务都会在主线程执行。例如，在子线程同步派发任务到主线程，则不会在当前线程执行。或者在主线程异步派发到主线程，也不会在其他线程执行。当以某种派发方式向某种队列多次派发任务后，执行结果如下表所示。

队列：队列是一种特殊的线性表，采用 FIFO（先进先出）的原则，GCD中有两种队列，串行队列和并发队列。两者都符合 FIFO（先进先出）的原则。两者的主要区别是：执行顺序不同，以及开启线程数不同。

串行队列：每次只有一个任务被执行。让任务一个接着一个地执行。（只开启一个线程，一个任务执行完毕后，再执行下一个任务）。

并发队列：可以让多个任务并发（同时）执行。（可以开启多个线程，并且同时执行任务）。

总结	同步派发	异步派发
串行队列	当前线程串行执行，阻塞当前线程	新建单个线程串行执行，不阻塞当前线程。
并发队列	当前线程串行执行，阻塞当前线程	新建多个线程并发执行，不阻塞当前线程。
主队列	主线程串行执行，阻塞当前线程	主线程串行执行，不阻塞当前线程

异步执行（async）虽然具有开启新线程的能力，但是并不一定开启新线程。
并发队列只有在异步执行的情况下才会出现并发。

GCD的使用步骤

创建一个队列（串行队列或并发队列）
将任务追加到任务的等待队列中，然后系统就会根据任务类型执行任务（同步执行或异步执行）

队列的创建和获取

    //串行队列创建
    dispatch_queue_t queue1 = dispatch_queue_create("test", DISPATCH_QUEUE_SERIAL);
    //并发队列的创建
    dispatch_queue_t queue2 = dispatch_queue_create("test", DISPATCH_QUEUE_CONCURRENT);
    //主队列
    dispatch_queue_t mainQueue = dispatch_get_main_queue();
    //全局并发队列 第一个参数表示队列的优先级，一般用DISPATCH_QUEUE_PRIORITY_DEFAULT，第二个参数s用0即可
    dispatch_queue_t globalQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

任务的创建方法

GCD提供了同步执行任务和异步执行任务

    //同步执行任务的创建方法
    dispatch_sync(queue, ^{
        //这里放同步执行任务代码
    })
    //异步执行任务的创建方法
    dispatch_async(queue, ^{
        //这里放异步执行任务代码
    });

GCD的使用组合

同步执行并发队列

同步执行的原则是不会开辟新的线程，就在当前线程执行，同步执行并发队列的情况，不会出现并发，因为同步执行不能开辟新的线程，只有当前一个线程，所以不存在并发，而且当前线程只有等待当前队列正在执行的任务执行完毕后，在能继续执行下面的操作，依然是执行完一个任务后，再执行下一个任务。

所有任务都在打印的syncConcurrent---begin和syncConcurrent---end之间执行的，同步任务需要等待队列的任务执行结束。

    //同步执行并发队列
    NSLog(@"syncConcurrent---begin");
    dispatch_queue_t queue = dispatch_queue_create("test", DISPATCH_QUEUE_CONCURRENT);
    dispatch_sync(queue, ^{
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
            NSLog(@"1---%@",[NSThread currentThread]);      // 打印当前线程
        }
    });
    dispatch_sync(queue, ^{
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
            NSLog(@"2---%@",[NSThread currentThread]);      // 打印当前线程
        }
    });
    dispatch_sync(queue, ^{
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
            NSLog(@"3---%@",[NSThread currentThread]);      // 打印当前线程
        }
    });
    
    NSLog(@"syncConcurrent---end");

syncConcurrent---begin
1---{number = 1, name = main}
1---{number = 1, name = main}
2---{number = 1, name = main}
2---{number = 1, name = main}
3---{number = 1, name = main}
3---{number = 1, name = main}
syncConcurrent---end

异步执行并发队列

异步执行会开辟新的线程，异步执行下并发队列会具备并发性，会开辟多个线程，同时执行多个任务。所以任务都end后才执行，说明任务的执行不需要做等待。

    NSLog(@"asyncConcurrent---begin");
    dispatch_queue_t queue = dispatch_queue_create("test", DISPATCH_QUEUE_CONCURRENT);
    dispatch_async(queue, ^{
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
            NSLog(@"1---%@",[NSThread currentThread]);      // 打印当前线程
        }
    });
    
    dispatch_async(queue, ^{
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
            NSLog(@"2---%@",[NSThread currentThread]);      // 打印当前线程
        }
    });
    
    dispatch_async(queue, ^{
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
            NSLog(@"2---%@",[NSThread currentThread]);      // 打印当前线程
        }
    });
    NSLog(@"asyncConcurrent---end");
    
    
    2019-08-06 18:39:33.823042+0800 MasonryTest[12796:1249138] asyncConcurrent---begin
    asyncConcurrent---end
    1---{number = 4, name = (null)}
    2---{number = 3, name = (null)}
    2---{number = 5, name = (null)}
    1---{number = 4, name = (null)}
    2---{number = 3, name = (null)}
    2---{number = 5, name = (null)}

同步执行串行队列

同步执行，并不会开辟新的线程，就在当前线程执行，串行队列的特点就是执行完一个任务之后，再执行下一个任务。

所有任务都在打印的syncConcurrent---begin和syncConcurrent---end之间执行（同步任务需要等待队列的任务执行结束）。

//同步执行 串行队列
    NSLog(@"asyncConcurrent---begin");
    
    dispatch_queue_t queue = dispatch_queue_create("test", DISPATCH_QUEUE_SERIAL);
    dispatch_sync(queue, ^{
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
            NSLog(@"1---%@",[NSThread currentThread]);      // 打印当前线程
        }
    });
    
    dispatch_sync(queue, ^{
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
            NSLog(@"2---%@",[NSThread currentThread]);      // 打印当前线程
        }
    });
    
    dispatch_sync(queue, ^{
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
            NSLog(@"3---%@",[NSThread currentThread]);      // 打印当前线程
        }
    });
    
    NSLog(@"asyncConcurrent---end");
    
    asyncConcurrent---begin
    1---{number = 1, name = main}
    1---{number = 1, name = main}
    2---{number = 1, name = main}
    2---{number = 1, name = main}
    3---{number = 1, name = main}
    3---{number = 1, name = main}
    asyncConcurrent---end

异步执行串行队列

异步执行会开辟新的线程，由于是串行队列，所以只开辟了一个线程。

所有任务是在打印的syncConcurrent---begin和syncConcurrent---end之后才开始执行的，异步执行不做任何等待，可以继续执行任务。

任务是按顺序执行的，串行队列只有一个任务执行完后，下一个任务才会执行。

    NSLog(@"asyncConcurrent---begin");
    
    dispatch_queue_t queue = dispatch_queue_create("test", DISPATCH_QUEUE_SERIAL);
    dispatch_async(queue, ^{
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
            NSLog(@"1---%@",[NSThread currentThread]);      // 打印当前线程
        }
    });
    
    dispatch_async(queue, ^{
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
            NSLog(@"2---%@",[NSThread currentThread]);      // 打印当前线程
        }
    });
    
    dispatch_async(queue, ^{
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
            NSLog(@"3---%@",[NSThread currentThread]);      // 打印当前线程
        }
    });
    
    NSLog(@"asyncConcurrent---end");
    
    asyncConcurrent---begin
    asyncConcurrent---end
    1---{number = 3, name = (null)}
    1---{number = 3, name = (null)}
    2---{number = 3, name = (null)}
    2---{number = 3, name = (null)}
    3---{number = 3, name = (null)}
    3---{number = 3, name = (null)}

同步执行主队列

同步执行 + 主队列在不同线程中调用结果也是不一样，在主线程中调用会出现死锁，而在其他线程中则不会。

在主线程中调用同步执行主队列

形成死锁。崩溃。

这是因为我们在主线程中执行syncMain方法，相当于把syncMain任务放到了主线程的队列中。而同步执行会等待当前队列中的任务执行完毕，才会接着执行。那么当我们把任务1追加到主队列中，任务1就在等待主线程处理完syncMain任务。而syncMain任务需要等待任务1执行完毕，才能接着执行。
那么，现在的情况就是syncMain任务和任务1都在等对方执行完毕。这样大家互相等待，所以就卡住了，所以我们的任务执行不了，而且syncMain---end也没有打印。

任务的追加和任务的执行互相等待，形成了死锁。当我们将任务1追加到主队列的时候，任务1就在等待主线程处理完syncMain任务，而syncMain任务有需要等待任务1执行完毕后才能接着执行。

- (void)syncMain{

    //在主线程中 同步执行 主队列
    NSLog(@"asyncConcurrent---begin");
    
    dispatch_queue_t queue = dispatch_get_main_queue();
    dispatch_sync(queue, ^{
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
            NSLog(@"1---%@",[NSThread currentThread]);      // 打印当前线程
        }
    });
    
    dispatch_sync(queue, ^{
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
            NSLog(@"2---%@",[NSThread currentThread]);      // 打印当前线程
        }
    });
    
    dispatch_sync(queue, ^{
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
            NSLog(@"3---%@",[NSThread currentThread]);      // 打印当前线程
        }
    });
    
    NSLog(@"asyncConcurrent---end");
}

其他线程中调用同步执行主队列

这样相当于将syncMain任务放到了其他线程中，而任务1，2，3则追加到了主队列，在主线程中执行。因为主队列现在没有正在执行的任务，所以会直接执行主队列任务1，然后2，3依次执行，不会形成死锁。

    [NSThread detachNewThreadWithBlock:^{
        [self syncMain];
    }];
    
    asyncConcurrent---begin
    1---{number = 1, name = main}
    1---{number = 1, name = main}
    2---{number = 1, name = main}
    3---{number = 1, name = main}
    3---{number = 1, name = main}
    asyncConcurrent---end

当前串行队列正在执行的任务所在的线程”继续向当前队列同步派发任务，就会造成死锁。因为串行队列是顺序执行的，后进入的任务必须等待前边的任务执行完成，而同步派发的任务则会阻塞当前线程直到自己执行完成。所以，当前线程如果就是“串行队列正在执行的任务所在的线程”，那么串行队列正在执行的任务就会阻塞，就无法执行后边同步派发的任务，同步派发的任务得不到执行，就不会取消当前线程的阻塞状态，从而造成了死锁。

异步执行主队列

所有任务都在主线程中执行，虽然异步执行有能力开辟线程，但因为是主队列，主队列的任务都在主线程中执行。

所有任务是在打印的syncConcurrent---begin和syncConcurrent---end之后才开始执行的。异步执行不需要等待，可以继续执行任务。

主队列是串行队列，因此队列中添加的任务需要按顺序执行。

    NSLog(@"asyncConcurrent---begin");
    
    dispatch_queue_t queue = dispatch_get_main_queue();
    dispatch_async(queue, ^{
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
            NSLog(@"1---%@",[NSThread currentThread]);      // 打印当前线程
        }
    });
    
    dispatch_async(queue, ^{
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
            NSLog(@"2---%@",[NSThread currentThread]);      // 打印当前线程
        }
    });
    
    dispatch_async(queue, ^{
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
            NSLog(@"3---%@",[NSThread currentThread]);      // 打印当前线程
        }
    });
    
    NSLog(@"asyncConcurrent---end");
    
    asyncConcurrent---begin
    asyncConcurrent---end
    1---{number = 1, name = main}
    2---{number = 1, name = main}
    2---{number = 1, name = main}
    3---{number = 1, name = main}
    3---{number = 1, name = main}

总结

同步执行不会开辟新的线程，同时会阻塞线程，需要等待追加到队列中的任务执行完毕后才能继续追加任务。无论是并发队列还是串行队列，队列中的任务都是顺序执行的，需要上一个任务执行完后，下一个任务才会执行。

异步执行具备开辟线程的能力，不会阻塞线程，可以不用等待追加进去的任务执行完就可以继续向队列中追加任务，因为异步执行不会影响代码向下继续执行。在串行队列下，异步执行只会开辟一个线程，因为串行队列的特点是一个任务执行完后下一个任务才会执行，因此开辟一个线程就足够了，串行队列中的任务按顺序依次执行。在并发队列下，会开辟多个线程，同步执行追加进去的任务。

同步和异步是指派发任务的方式是否需要等待，同步需要等待，异步不需要等待。串行和并发是指已经在队列中的任务，执行时后面的任务的执行是否需要等待，串行是按顺序执行完后再执行下一个，并发则可以不需要等待前面的任务执行完时直接进行执行。

主队列是一个特殊情况，添加到主队列中的任务必须要在主线程中执行。因此在主线程中调用同步执行主队列会形成死锁，主线程需要把任务派发下去，同步则会阻塞主线程，这样执行任务就需要等待派发完才能执行，但是派发任务有需要执行任务执行完毕后才能派发，因此派发任务和执行任务出现了互相等待的情况，但是在其他线程中调用同步执行主队列则不会形成死锁，此时派发任务在子线程中进行，执行任务在主线程中执行。异步主队列仍然是在主线程中执行，但是异步不需要等待任务执行完在追加新的任务，但是任务追加到主队列依照串行队列的原则顺序执行，等待上一个执行完后，再执行下一个。

GCD线程间的通信

执行一些耗时操作的时候，开辟子线程，执行完毕后，回到主线程更新UI。

dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        for (int i = 0; i<2; i++) {
            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
            NSLog(@"3---%@",[NSThread currentThread]);      // 打印当前线程
        }
        
        dispatch_async(dispatch_get_main_queue(), ^{
            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
            NSLog(@"2---%@",[NSThread currentThread]);      // 打印当前线程
        });
    });
    
3---{number = 3, name = (null)}
3---{number = 3, name = (null)}
2---{number = 1, name = main}

GCD的其他方法。

GCD的栅栏方法：dispatch_barrier_async

我们有时需要异步执行两组操作，而且第一组操作执行完之后，才能开始执行第二组操作。这样我们就需要一个相当于栅栏一样的一个方法将两组异步执行的操作组给分割起来，当然这里的操作组里可以包含一个或多个任务。这就需要用到dispatch_barrier_async方法在两个操作组间形成栅栏。
dispatch_barrier_async函数会等待前边追加到并发队列中的任务全部执行完毕之后，再将指定的任务追加到该异步队列中。然后在dispatch_barrier_async函数追加的任务执行完毕之后，异步队列才恢复为一般动作，接着追加任务到该异步队列并开始执行。

假设有6个任务分为两组，需求是第一组的三个并发执行，第二组的三个等第一组的三个都执行完毕后再并发执行。

从执行结果中可以看出，在执行完栅栏前面的操作之后，才执行栅栏操作，最后再执行栅栏后边的操作。

    dispatch_queue_t queue = dispatch_queue_create("test", DISPATCH_QUEUE_CONCURRENT);
    dispatch_async(queue, ^{
        for (int i = 0; i<2; i++) {
            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
            NSLog(@"1---%@",[NSThread currentThread]);      // 打印当前线程
        }
    });
    
    dispatch_async(queue, ^{
        for (int i = 0; i<2; i++) {
            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
            NSLog(@"2---%@",[NSThread currentThread]);      // 打印当前线程
        }
    });
    
    dispatch_barrier_sync(queue, ^{
        for (int i = 0; i<2; i++) {
            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
            NSLog(@"barrier---%@",[NSThread currentThread]);      // 打印当前线程
        }
    });

    dispatch_async(queue, ^{
        for (int i = 0; i<2; i++) {
            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
            NSLog(@"4---%@",[NSThread currentThread]);      // 打印当前线程
        }
    });
    
    dispatch_async(queue, ^{
        for (int i = 0; i<2; i++) {
            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
            NSLog(@"5---%@",[NSThread currentThread]);      // 打印当前线程
        }
    });
    
    2---{number = 3, name = (null)}
    1---{number = 4, name = (null)}
    2---{number = 3, name = (null)}
    1---{number = 4, name = (null)}
    barrier---{number = 1, name = main}
    barrier---{number = 1, name = main}
    4---{number = 4, name = (null)}
    5---{number = 5, name = (null)}
    4---{number = 4, name = (null)}
    5---{number = 5, name = (null)}

GCD延时执行方法：dispatch_after

在指定时间（例如3秒）之后执行某个任务。可以用 GCD 的dispatch_after函数来实现。

需要注意的是：dispatch_after函数并不是在指定时间之后才开始执行处理，而是在指定时间之后将任务追加到主队列中。严格来说，这个时间并不是绝对准确的，但想要大致延迟执行任务，dispatch_after函数是很有效的。

    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        // 2.0秒后异步追加任务代码到主队列，并开始执行
        NSLog(@"after---%@",[NSThread currentThread]);  // 打印当前线程
    });

GCD一次性代码：dispatch_once

    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        // 只执行1次的代码(这里面默认是线程安全的)
    });

GCD单例

+ (DJSingleton *)shareInstance{
    static DJSingleton * s_instance_dj_singleton = nil ;
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        if (s_instance_dj_manager == nil) {
            s_instance_dj_manager = [[DJSingleton alloc] init];
        }
    });
    return (DJSingleton *)s_instance_dj_singleton;
}

GCD快速迭代方法：dispatch_apply

通常我们会用 for 循环遍历，但是 GCD 给我们提供了快速迭代的函数dispatch_apply。dispatch_apply按照指定的次数将指定的任务追加到指定的队列中，并等待全部队列执行结束。

如果是在串行队列中使用 dispatch_apply，那么就和 for 循环一样，按顺序同步执行。可这样就体现不出快速迭代的意义了。
我们可以利用并发队列进行异步执行。比如说遍历 0~5 这6个数字，for 循环的做法是每次取出一个元素，逐个遍历。dispatch_apply 可以在多个线程中同时（异步）遍历多个数字。
还有一点，无论是在串行队列，还是并发队列中，dispatch_apply 都会等待全部任务执行完毕，这点就像是同步操作，也像是队列组中的 dispatch_group_wait方法。

    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    
    NSLog(@"apply---begin");
    dispatch_apply(6, queue, ^(size_t index) {
        NSLog(@"%zd---%@",index, [NSThread currentThread]);
    });
    NSLog(@"apply---end");
    
    apply---begin
    2---{number = 1, name = main}
    5---{number = 6, name = (null)}
    1---{number = 4, name = (null)}
    3---{number = 5, name = (null)}
    0---{number = 3, name = (null)}
    4---{number = 7, name = (null)}
    apply---end

GCD 队列组：dispatch_group

分别异步执行2个耗时任务，然后当2个耗时任务都执行完毕后再回到主线程执行任务。这时候我们可以用到 GCD 的队列组。

调用队列组的 dispatch_group_async 先把任务放到队列中，然后将队列放入队列组中。或者使用队列组的 dispatch_group_enter、dispatch_group_leave 组合来实现dispatch_group_async。
调用队列组的 dispatch_group_notify 回到指定线程执行任务。或者使用 dispatch_group_wait 回到当前线程继续向下执行（会阻塞当前线程）。

dispatch_group_notify

/**
 * 队列组 dispatch_group_notify
 */
- (void)groupNotify {
    NSLog(@"currentThread---%@",[NSThread currentThread]);  // 打印当前线程
    NSLog(@"group---begin");
    
    dispatch_group_t group =  dispatch_group_create();
    
    dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        // 追加任务1
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
            NSLog(@"1---%@",[NSThread currentThread]);      // 打印当前线程
        }
    });
    
    dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        // 追加任务2
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
            NSLog(@"2---%@",[NSThread currentThread]);      // 打印当前线程
        }
    });
    
    dispatch_group_notify(group, dispatch_get_main_queue(), ^{
        // 等前面的异步任务1、任务2都执行完毕后，回到主线程执行下边任务
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
            NSLog(@"3---%@",[NSThread currentThread]);      // 打印当前线程
        }
        NSLog(@"group---end");
    });
}

dispatch_group_wait

会阻塞当前线程

/**
 * 队列组 dispatch_group_wait
 */
- (void)groupWait {
    NSLog(@"currentThread---%@",[NSThread currentThread]);  // 打印当前线程
    NSLog(@"group---begin");
    
    dispatch_group_t group =  dispatch_group_create();
    
    dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        // 追加任务1
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
            NSLog(@"1---%@",[NSThread currentThread]);      // 打印当前线程
        }
    });
    
    dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        // 追加任务2
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
            NSLog(@"2---%@",[NSThread currentThread]);      // 打印当前线程
        }
    });
    
    // 等待上面的任务全部完成后，会往下继续执行（会阻塞当前线程）
    dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
    
    NSLog(@"group---end");
}

dispatch_group_enter、dispatch_group_leave

/**
 * 队列组 dispatch_group_enter、dispatch_group_leave
 */
- (void)groupEnterAndLeave
{
    NSLog(@"currentThread---%@",[NSThread currentThread]);  // 打印当前线程
    NSLog(@"group---begin");
    
    dispatch_group_t group = dispatch_group_create();
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    dispatch_group_enter(group);
    dispatch_async(queue, ^{
        // 追加任务1
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
            NSLog(@"1---%@",[NSThread currentThread]);      // 打印当前线程
        }
        dispatch_group_leave(group);
    });
    
    dispatch_group_enter(group);
    dispatch_async(queue, ^{
        // 追加任务2
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
            NSLog(@"2---%@",[NSThread currentThread]);      // 打印当前线程
        }
        dispatch_group_leave(group);
    });
    
    dispatch_group_notify(group, dispatch_get_main_queue(), ^{
        // 等前面的异步操作都执行完毕后，回到主线程.
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
            NSLog(@"3---%@",[NSThread currentThread]);      // 打印当前线程
        }
        NSLog(@"group---end");
    });
    
}

GCD 信号量：dispatch_semaphore

GCD 中的信号量是指 Dispatch Semaphore，是持有计数的信号。类似于过高速路收费站的栏杆。可以通过时，打开栏杆，不可以通过时，关闭栏杆。在 Dispatch Semaphore 中，使用计数来完成这个功能，计数小于 0 时等待，不可通过。计数为 0 或大于 0 时，计数减 1 且不等待，可通过。
Dispatch Semaphore 提供了三个函数

dispatch_semaphore_create：创建一个 Semaphore 并初始化信号的总量
dispatch_semaphore_signal：发送一个信号，让信号总量加 1
dispatch_semaphore_wait：可以使总信号量减 1，信号总量小于 0 时就会一直等待（阻塞所在线程），否则就可以正常执行。

Dispatch Semaphore 在实际开发中主要用于：

保持线程同步，将异步执行任务转换为同步执行任务
保证线程安全，为线程加锁

/**
 * semaphore 线程同步
 */
- (void)semaphoreSync {
    
    NSLog(@"currentThread---%@",[NSThread currentThread]);  // 打印当前线程
    NSLog(@"semaphore---begin");
    
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
    
    __block int number = 0;
    dispatch_async(queue, ^{
        // 追加任务1
        [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
        NSLog(@"1---%@",[NSThread currentThread]);      // 打印当前线程
        
        number = 100;
        
        dispatch_semaphore_signal(semaphore);
    });
    
    dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
    NSLog(@"semaphore---end,number = %zd",number);
}

semaphore 初始创建时计数为 0。
异步执行将任务 1 追加到队列之后，不做等待，接着执行dispatch_semaphore_wait方法，semaphore 减 1，此时 semaphore == -1，当前线程进入等待状态。
然后，异步任务 1 开始执行。任务1执行到dispatch_semaphore_signal之后，总信号量加1，此时 semaphore == 0，正在被阻塞的线程（主线程）恢复继续执行。
最后打印semaphore---end,number = 100。

这样就实现了线程同步，将异步执行任务转换为同步执行任务

/**
 * 线程安全：使用 semaphore 加锁
 * 初始化火车票数量、卖票窗口(线程安全)、并开始卖票
 */
- (void)initTicketStatusSave {
    NSLog(@"currentThread---%@",[NSThread currentThread]);  // 打印当前线程
    NSLog(@"semaphore---begin");
    
    semaphoreLock = dispatch_semaphore_create(1);
    
    self.ticketSurplusCount = 50;
    
    // queue1 代表北京火车票售卖窗口
    dispatch_queue_t queue1 = dispatch_queue_create("net.bujige.testQueue1", DISPATCH_QUEUE_SERIAL);
    // queue2 代表上海火车票售卖窗口
    dispatch_queue_t queue2 = dispatch_queue_create("net.bujige.testQueue2", DISPATCH_QUEUE_SERIAL);
    
    __weak typeof(self) weakSelf = self;
    dispatch_async(queue1, ^{
        [weakSelf saleTicketSafe];
    });
    
    dispatch_async(queue2, ^{
        [weakSelf saleTicketSafe];
    });
}

/**
 * 售卖火车票(线程安全)
 */
- (void)saleTicketSafe {
    while (1) {
        // 相当于加锁
        dispatch_semaphore_wait(semaphoreLock, DISPATCH_TIME_FOREVER);
        
        if (self.ticketSurplusCount > 0) {  //如果还有票，继续售卖
            self.ticketSurplusCount--;
            NSLog(@"%@", [NSString stringWithFormat:@"剩余票数：%d 窗口：%@", self.ticketSurplusCount, [NSThread currentThread]]);
            [NSThread sleepForTimeInterval:0.2];
        } else { //如果已卖完，关闭售票窗口
            NSLog(@"所有火车票均已售完");
            
            // 相当于解锁
            dispatch_semaphore_signal(semaphoreLock);
            break;
        }
        
        // 相当于解锁
        dispatch_semaphore_signal(semaphoreLock);
    }
}

通过信号量的控制，保证两个售票窗口不会同时修改火车票数量，从而实现线程安全。