GCD与多线程

GCD

1.进程与线程分别是什么意思？

1.进程是一个具有一定独立功能的程序关于某次数据集合的一次运行活动，它是操作系统分配资源的基本单元.

2.进程是指在系统中正在运行的一个应用程序，就是一段程序的执行过程,我们可以理解为手机上的一个app.

3.每个进程之间是独立的，每个进程均运行在其专用且受保护的内存空间内，拥有独立运行所需的全部资源

2.进程

1.程序执行流的最小单元，线程是进程中的一个实体

2.一个进程要想执行任务,必须至少有一条线程.应用程序启动的时候，系统会默认开启一条线程,也就是主线程

3.进程和线程的关系

1.线程是进程的执行单元，进程的所有任务都在线程中执行

2.线程是 CPU 分配资源和调度的最小单位

3.一个程序可以对应多个进程(多进程),一个进程中可有多个线程,但至少要有一条线程

4.同一个进程内的线程共享进程资源

1. 同步执行 + 并发队列

2. 异步执行 + 并发队列

3. 同步执行 + 串行队列

4. 异步执行 + 串行队列

5. 同步执行 + 主队列

6. 异步执行 + 主队列

区别	并发队列	串行队列	主队列
同步（sync）	没有开启新线程，串行执行任务	没有开启新线程，串行执行任务	死锁卡住不执行
异步（async）	有开启新线程，并发执行任务	有开启新线程（1条），串行执行任务	没有开启新线程，串行执行任务

『主线程』 中调用 『主队列』+『同步执行』 会导致死锁问题。
这是因为 主队列中追加的同步任务 和 主线程本身的任务 两者之间相互等待，阻塞了 『主队列』，最终造成了主队列所在的线程（主线程）死锁问题。

dispatch_queue_t queue = dispatch_queue_create("test.queue", DISPATCH_QUEUE_SERIAL);
dispatch_async(queue, ^{    // 异步执行 + 串行队列
    dispatch_sync(queue, ^{  // 同步执行 + 当前串行队列
        // 追加任务 1
        [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
        NSLog(@"1---%@",[NSThread currentThread]);      // 打印当前线程
    });
});

执行上面的代码会导致 串行队列中追加的任务 和 串行队列中原有的任务 两者之间相互等待，阻塞了『串行队列』，最终造成了串行队列所在的线程（子线程）死锁问题。

主队列造成死锁也是基于这个原因，所以，这也进一步说明了主队列其实并不特殊。

通俗解释

假设现在有 5 个人要穿过一道门禁，这道门禁总共有 10 个入口，管理员可以决定同一时间打开几个入口，可以决定同一时间让一个人单独通过还是多个人一起通过。不过默认情况下，管理员只开启一个入口，且一个通道一次只能通过一个人。

• 5 个人表示有 5 个任务，10 个入口代表 10 条线程。
• 串行队列 好比是 5 个人排成一支长队。
• 并发队列 好比是 5 个人排成多支队伍，比如 2 队，或者 3 队。
• 同步任务 好比是管理员只开启了一个入口（当前线程）。
• 异步任务 好比是管理员同时开启了多个入口（当前线程 + 新开的线程）。

『异步执行 + 并发队列』 可以理解为：现在管理员开启了多个入口（比如 3 个入口），5 个人排成了多支队伍（比如 3 支队伍），这样这 5 个人就可以 3 个人同时一起穿过门禁了。

『同步执行 + 并发队列』 可以理解为：现在管理员只开启了 1 个入口，5 个人排成了多支队伍。虽然这 5 个人排成了多支队伍，但是只开了 1 个入口啊，这 5 个人虽然都想快点过去，但是 1 个入口一次只能过 1 个人，所以大家就只好一个接一个走过去了，表现的结果就是：顺次通过入口。

换成 GCD 里的语言就是说：

• 『异步执行 + 并发队列』就是：系统开启了多个线程（主线程+其他子线程），任务可以多个同时运行。
• 『同步执行 + 并发队列』就是：系统只默认开启了一个主线程，没有开启子线程，虽然任务处于并发队列中，但也只能一个接一个执行了。

同步执行 + 并发队列

/**
 * 同步执行 + 并发队列
 * 特点：在当前线程中执行任务，不会开启新线程，执行完一个任务，再执行下一个任务。
 */
- (void)syncConcurrent {
    NSLog(@"currentThread---%@",[NSThread currentThread]);  // 打印当前线程
    NSLog(@"syncConcurrent---begin");
    
    dispatch_queue_t queue = dispatch_queue_create("fj.testQueue", DISPATCH_QUEUE_CONCURRENT);
    
    dispatch_sync(queue, ^{
        // 追加任务 1
        [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
        NSLog(@"1---%@",[NSThread currentThread]);      // 打印当前线程
    });
    
    dispatch_sync(queue, ^{
        // 追加任务 2
        [NSThread sleepForTimeInterval:1];              // 模拟耗时操作
        NSLog(@"2---%@",[NSThread currentThread]);      // 打印当前线程
    });
    
    dispatch_sync(queue, ^{
        // 追加任务 3
        [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
        NSLog(@"3---%@",[NSThread currentThread]);      // 打印当前线程
    });
    
    NSLog(@"syncConcurrent---end");
}

2021-09-28 11:15:11.185511+0800 FJTest[76407:2498751] currentThread---{number = 1, name = main}

2021-09-28 11:15:11.185616+0800 FJTest[76407:2498751] syncConcurrent---begin

2021-09-28 11:15:13.185959+0800 FJTest[76407:2498751] 1---{number = 1, name = main}

2021-09-28 11:15:14.187323+0800 FJTest[76407:2498751] 2---{number = 1, name = main}

2021-09-28 11:15:16.188779+0800 FJTest[76407:2498751] 3---{number = 1, name = main}

2021-09-28 11:15:16.189047+0800 FJTest[76407:2498751] syncConcurrent---end

//所有任务都是在当前线程（主线程）中执行的，没有开启新的线程（同步执行不具备开启新线程的能力）。

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

//任务按顺序执行的。按顺序执行的原因：虽然 并发队列 可以开启多个线程，并且同时执行多个任务。但是因为本身不能创建新线程，只有当前线程这一个线程（同步任务 不具备开启新线程的能力），所以也就不存在并发。而且当前线程只有等待当前队列中正在执行的任务执行完毕之后，才能继续接着执行下面的操作（同步任务 需要等待队列的任务执行结束）。所以任务只能一个接一个按顺序执行，不能同时被执行。

异步执行 + 并发队列

/**
 * 异步执行 + 并发队列
 * 特点：可以开启多个线程，任务交替（同时）执行。
 */
- (void)asyncConcurrent {
    NSLog(@"currentThread---%@",[NSThread currentThread]);  // 打印当前线程
    NSLog(@"asyncConcurrent---begin");
    
    dispatch_queue_t queue = dispatch_queue_create("testQueue", DISPATCH_QUEUE_CONCURRENT);
    
    dispatch_async(queue, ^{
        // 追加任务 1
        [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
        NSLog(@"1---%@",[NSThread currentThread]);      // 打印当前线程
    });
    
    dispatch_async(queue, ^{
        // 追加任务 2
        [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
        NSLog(@"2---%@",[NSThread currentThread]);      // 打印当前线程
    });
    
    dispatch_async(queue, ^{
        // 追加任务 3
        [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
        NSLog(@"3---%@",[NSThread currentThread]);      // 打印当前线程
    });
    
    NSLog(@"asyncConcurrent---end");
}

2021-09-28 11:22:36.814672+0800 FJTest[76561:2506924] currentThread---{number = 1, name = main}

2021-09-28 11:22:36.814774+0800 FJTest[76561:2506924] asyncConcurrent---begin

2021-09-28 11:22:36.814875+0800 FJTest[76561:2506924] asyncConcurrent---end

2021-09-28 11:22:38.820207+0800 FJTest[76561:2507061] 1---{number = 4, name = (null)}

2021-09-28 11:22:38.820208+0800 FJTest[76561:2507060] 3---{number = 5, name = (null)}

2021-09-28 11:22:38.820231+0800 FJTest[76561:2507058] 2---{number = 3, name = (null)}

//除了当前线程（主线程），系统又开启了 3 个线程，并且任务是交替/同时执行的。（异步执行 具备开启新线程的能力。且 并发队列 可开启多个线程，同时执行多个任务）。

//所有任务是在打印的 syncConcurrent---begin 和 syncConcurrent---end 之后才执行的。说明当前线程没有等待，而是直接开启了新线程，在新线程中执行任务（异步执行 不做等待，可以继续执行任务）

同步执行 + 串行队列

/**
 * 同步执行 + 串行队列
 * 特点：不会开启新线程，在当前线程执行任务。任务是串行的，执行完一个任务，再执行下一个任务。
 */
- (void)syncSerial {
    NSLog(@"currentThread---%@",[NSThread currentThread]);  // 打印当前线程
    NSLog(@"syncSerial---begin");
    
    dispatch_queue_t queue = dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_SERIAL);
    
    dispatch_sync(queue, ^{
        // 追加任务 1
        [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
        NSLog(@"1---%@",[NSThread currentThread]);      // 打印当前线程
    });
    dispatch_sync(queue, ^{
        // 追加任务 2
        [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
        NSLog(@"2---%@",[NSThread currentThread]);      // 打印当前线程
    });
    dispatch_sync(queue, ^{
        // 追加任务 3
        [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
        NSLog(@"3---%@",[NSThread currentThread]);      // 打印当前线程
    });
    
    NSLog(@"syncSerial---end");
}

2021-09-28 11:31:34.938424+0800 FJTest[76735:2516407] currentThread---{number = 1, name = main}

2021-09-28 11:31:34.938535+0800 FJTest[76735:2516407] syncSerial---begin

2021-09-28 11:31:36.939917+0800 FJTest[76735:2516407] 1---{number = 1, name = main}

2021-09-28 11:31:38.941294+0800 FJTest[76735:2516407] 2---{number = 1, name = main}

2021-09-28 11:31:40.942730+0800 FJTest[76735:2516407] 3---{number = 1, name = main}

2021-09-28 11:31:40.943082+0800 FJTest[76735:2516407] syncSerial---end

//所有任务都是在当前线程（主线程）中执行的，并没有开启新的线程（同步执行 不具备开启新线程的能力）。

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

//任务是按顺序执行的（串行队列 每次只有一个任务被执行，任务一个接一个按顺序执行）。

异步执行 + 串行队列

/**
 * 异步执行 + 串行队列
 * 特点：会开启新线程，但是因为任务是串行的，执行完一个任务，再执行下一个任务。
 */
- (void)asyncSerial {
    NSLog(@"currentThread---%@",[NSThread currentThread]);  // 打印当前线程
    NSLog(@"asyncSerial---begin");
    
    dispatch_queue_t queue = dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_SERIAL);
    
    dispatch_async(queue, ^{
        // 追加任务 1
        [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
        NSLog(@"1---%@",[NSThread currentThread]);      // 打印当前线程
    });
    dispatch_async(queue, ^{
        // 追加任务 2
//        [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
        NSLog(@"2---%@",[NSThread currentThread]);      // 打印当前线程
    });
    dispatch_async(queue, ^{
        // 追加任务 3
//        [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
        NSLog(@"3---%@",[NSThread currentThread]);      // 打印当前线程
    });
    
    NSLog(@"asyncSerial---end");
}

2021-09-28 14:50:24.939275+0800 FJTest[80244:2665678] currentThread---{number = 1, name = main}

2021-09-28 14:50:24.939400+0800 FJTest[80244:2665678] asyncSerial---begin

2021-09-28 14:50:24.939495+0800 FJTest[80244:2665678] asyncSerial---end

2021-09-28 14:50:26.942878+0800 FJTest[80244:2665811] 1---{number = 3, name = (null)}

2021-09-28 14:50:26.943083+0800 FJTest[80244:2665811] 2---{number = 3, name = (null)}

2021-09-28 14:50:26.943253+0800 FJTest[80244:2665811] 3---{number = 3, name = (null)}

//开启了一条新线程（异步执行 具备开启新线程的能力，串行队列 只开启一个线程）。

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

//任务是按顺序执行的（串行队列 每次只有一个任务被执行，任务一个接一个按顺序执行）。

同步执行 + 主队列

/**
 * 同步执行 + 主队列
 * 特点(主线程调用)：互等卡主不执行。
 * 特点(其他线程调用)：不会开启新线程，执行完一个任务，再执行下一个任务。
 */
- (void)syncMain {
    
    NSLog(@"currentThread---%@",[NSThread currentThread]);  // 打印当前线程
    NSLog(@"syncMain---begin");
    
    dispatch_queue_t queue = dispatch_get_main_queue();
    
    dispatch_sync(queue, ^{
        // 追加任务 1
        [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
        NSLog(@"1---%@",[NSThread currentThread]);      // 打印当前线程
    });
    
    dispatch_sync(queue, ^{
        // 追加任务 2
        [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
        NSLog(@"2---%@",[NSThread currentThread]);      // 打印当前线程
    });
    
    dispatch_sync(queue, ^{
        // 追加任务 3
        [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
        NSLog(@"3---%@",[NSThread currentThread]);      // 打印当前线程
    });
    
    NSLog(@"syncMain---end");
}

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

异步执行 + 主队列

/**
 * 异步执行 + 主队列
 * 特点：只在主线程中执行任务，执行完一个任务，再执行下一个任务
 */
- (void)asyncMain {
    NSLog(@"currentThread---%@",[NSThread currentThread]);  // 打印当前线程
    NSLog(@"asyncMain---begin");
    
    dispatch_queue_t queue = dispatch_get_main_queue();
    
    dispatch_async(queue, ^{
        // 追加任务 1
//        [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
        NSLog(@"1---%@",[NSThread currentThread]);      // 打印当前线程
    });
    
    dispatch_async(queue, ^{
        // 追加任务 2
//        [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
        NSLog(@"2---%@",[NSThread currentThread]);      // 打印当前线程
    });
    
    dispatch_async(queue, ^{
        // 追加任务 3
//        [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
        NSLog(@"3---%@",[NSThread currentThread]);      // 打印当前线程
    });
         
    [NSThread sleepForTimeInterval:1];              // 模拟耗时操作

    NSLog(@"asyncMain---end");
}

2021-09-28 15:00:13.830038+0800 FJTest[80453:2675783] currentThread---{number = 1, name = main}

2021-09-28 15:00:13.830137+0800 FJTest[80453:2675783] asyncMain---begin

2021-09-28 15:00:14.831335+0800 FJTest[80453:2675783] asyncMain---end

2021-09-28 15:00:14.933970+0800 FJTest[80453:2675783] 1---{number = 1, name = main}

2021-09-28 15:00:14.934106+0800 FJTest[80453:2675783] 2---{number = 1, name = main}

2021-09-28 15:00:14.934196+0800 FJTest[80453:2675783] 3---{number = 1, name = main}

//所有任务都是在当前线程（主线程）中执行的，并没有开启新的线程（虽然 异步执行 具备开启线程的能力，但因为是主队列，所以所有任务都在主线程中）。

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

//任务是按顺序执行的（因为主队列是 串行队列，每次只有一个任务被执行，任务一个接一个按顺序执行）

栅栏方法 dispatch_barrier_async

/**
 * 栅栏方法 dispatch_barrier_async
 */
- (void)barrier {
    dispatch_queue_t queue = dispatch_queue_create("fjtestQueue", DISPATCH_QUEUE_CONCURRENT);
    
    dispatch_async(queue, ^{
        // 追加任务 1
        [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
        NSLog(@"1---%@",[NSThread currentThread]);      // 打印当前线程
    });
    dispatch_async(queue, ^{
        // 追加任务 2
        [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
        NSLog(@"2---%@",[NSThread currentThread]);      // 打印当前线程
    });
    
    dispatch_barrier_async(queue, ^{
        // 追加任务 barrier
        [NSThread sleepForTimeInterval:1];              // 模拟耗时操作
        NSLog(@"barrier---%@",[NSThread currentThread]);// 打印当前线程
    });

    dispatch_async(queue, ^{
           // 追加任务 3
           [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
           NSLog(@"3---%@",[NSThread currentThread]);      // 打印当前线程
       });
       dispatch_async(queue, ^{
           // 追加任务 4
           [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
           NSLog(@"4---%@",[NSThread currentThread]);      // 打印当前线程
       });
}

2021-09-28 15:05:56.245245+0800 FJTest[80569:2682225] 1---{number = 4, name = (null)}

2021-09-28 15:05:56.245256+0800 FJTest[80569:2682219] 2---{number = 3, name = (null)}

2021-09-28 15:05:57.245985+0800 FJTest[80569:2682225] barrier---{number = 4, name = (null)}

2021-09-28 15:05:59.249938+0800 FJTest[80569:2682225] 3---{number = 4, name = (null)}

2021-09-28 15:05:59.249946+0800 FJTest[80569:2682219] 4---{number = 3, name = (null)}

//在执行完栅栏前面的操作之后，才执行栅栏操作，最后再执行栅栏后边的操作。

快速迭代方法 dispatch_apply

/**
 * 快速迭代方法 dispatch_apply
 */
- (void)apply {
    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");
}

2021-09-28 15:09:55.609958+0800 FJTest[80653:2686459] apply---begin

2021-09-28 15:09:55.610190+0800 FJTest[80653:2686459] 0---{number = 1, name = main}

2021-09-28 15:09:55.610196+0800 FJTest[80653:2686522] 1---{number = 3, name = (null)}

2021-09-28 15:09:55.610201+0800 FJTest[80653:2686518] 2---{number = 7, name = (null)}

2021-09-28 15:09:55.610201+0800 FJTest[80653:2686516] 4---{number = 4, name = (null)}

2021-09-28 15:09:55.610206+0800 FJTest[80653:2686519] 3---{number = 5, name = (null)}

2021-09-28 15:09:55.610204+0800 FJTest[80653:2686517] 5---{number = 6, name = (null)}

2021-09-28 15:09:55.610361+0800 FJTest[80653:2686459] apply---end

//并发队列中异步执行任务，所以各个任务的执行时间长短不定，最后结束顺序也不定。但是 apply---end 一定在最后执行。这是因为 dispatch_apply 方法会等待全部任务执行完毕。

//如果是在串行队列中使用 dispatch_apply，那么就和 for 循环一样，按顺序同步执行。但是这样就体现不出快速迭代的意义了。

//我们可以利用并发队列进行异步执行。比如说遍历 0~5 这 6 个数字，for 循环的做法是每次取出一个元素，逐个遍历。dispatch_apply 可以 在多个线程中同时（异步）遍历多个数字。

//还有一点，无论是在串行队列，还是并发队列中，dispatch_apply 都会等待全部任务执行完毕，这点就像是同步操作，也像是队列组中的 dispatch_group_wait方法

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

监听 group 中任务的完成状态，当所有的任务都执行完成后，追加任务到 group 中，并执行任务。

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

    });
    NSLog(@"group---end");

}

2021-09-28 15:13:50.983921+0800 FJTest[80738:2691427] group---begin

2021-09-28 15:13:50.984004+0800 FJTest[80738:2691427] group---end

2021-09-28 15:13:51.988288+0800 FJTest[80738:2691523] 2---{number = 3, name = (null)}

2021-09-28 15:13:52.985618+0800 FJTest[80738:2691521] 1---{number = 4, name = (null)}

2021-09-28 15:13:53.986353+0800 FJTest[80738:2691427] 3---{number = 1, name = main}

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
        [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
        NSLog(@"1---%@",[NSThread currentThread]);      // 打印当前线程
    });
    
    dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        // 追加任务 2
        [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
        NSLog(@"2---%@",[NSThread currentThread]);      // 打印当前线程
    });
    
    // 等待上面的任务全部完成后，会往下继续执行（会阻塞当前线程）
    dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
    
    NSLog(@"group---end");
    
}

2021-09-28 15:19:12.601615+0800 FJTest[80847:2697645] group---begin

2021-09-28 15:19:14.604711+0800 FJTest[80847:2697780] 2---{number = 3, name = (null)}

2021-09-28 15:19:14.604713+0800 FJTest[80847:2697781] 1---{number = 4, name = (null)}

2021-09-28 15:19:14.605147+0800 FJTest[80847:2697645] group---end

暂停当前线程（阻塞当前线程），等待指定的 group 中的任务执行完成后，才会往下继续执行。

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
        [NSThread sleepForTimeInterval:3];              // 模拟耗时操作
        NSLog(@"1---%@",[NSThread currentThread]);      // 打印当前线程

        dispatch_group_leave(group);
    });
    
    dispatch_group_enter(group);
    dispatch_async(queue, ^{
        // 追加任务 2
        [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
        NSLog(@"2---%@",[NSThread currentThread]);      // 打印当前线程
        
        dispatch_group_leave(group);
    });
    
    dispatch_group_notify(group, dispatch_get_main_queue(), ^{
        // 等前面的异步操作都执行完毕后，回到主线程.
        [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
        NSLog(@"3---%@",[NSThread currentThread]);      // 打印当前线程
        
    });
    NSLog(@"group---end");
}

2021-09-28 15:23:20.103341+0800 FJTest[80946:2703179] group---begin

2021-09-28 15:23:20.103434+0800 FJTest[80946:2703179] group---end

2021-09-28 15:23:22.106956+0800 FJTest[80946:2703363] 2---{number = 3, name = (null)}

2021-09-28 15:23:23.108610+0800 FJTest[80946:2703362] 1---{number = 4, name = (null)}

2021-09-28 15:23:25.109869+0800 FJTest[80946:2703179] 3---{number = 1, name = main}

//dispatch_group_enter 标志着一个任务追加到 group，执行一次，相当于 group 中未执行完毕任务数 +1

//dispatch_group_leave 标志着一个任务离开了 group，执行一次，相当于 group 中未执行完毕任务数 -1。

//当 group 中未执行完毕任务数为0的时候，才会使 dispatch_group_wait 解除阻塞，以及执行追加到 dispatch_group_notify 中的任务。

信号量：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 在实际开发中主要用于：

1.保持线程同步，将异步执行任务转换为同步执行任务

2.保证线程安全，为线程加锁

*/
//利用 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;
    __block int number2 = 0;

    dispatch_async(queue, ^{
        // 追加任务 1
        [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
        NSLog(@"1---%@",[NSThread currentThread]);      // 打印当前线程
        
        number = 100;
        
        dispatch_semaphore_signal(semaphore);
    });
    
    
    dispatch_async(queue, ^{
        // 追加任务 2
        [NSThread sleepForTimeInterval:1];              // 模拟耗时操作
        NSLog(@"2---%@",[NSThread currentThread]);      // 打印当前线程
        
        number2 = 200;
        
        dispatch_semaphore_signal(semaphore);
    });
    
    dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
    dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);

    NSLog(@"semaphore---end,number = %d , number2 = %d",number,number2);
}

2021-09-28 15:39:13.948041+0800 FJTest[81245:2718974] semaphore---begin

2021-09-28 15:39:14.951608+0800 FJTest[81245:2719055] 2---{number = 3, name = (null)}

2021-09-28 15:39:15.951949+0800 FJTest[81245:2719058] 1---{number = 4, name = (null)}

2021-09-28 15:39:15.952344+0800 FJTest[81245:2718974] semaphore---end,number = 100 , number2 = 200