iOS 边学边记 GCD使用详解

一了百-了

于 2020-12-15 17:50:35 发布

阅读量572

点赞数

分类专栏： iOS 边学边记文章标签： objective-c xcode ios

原文链接：https://juejin.cn/post/6844903957198798862

版权

iOS 边学边记专栏收录该内容

27 篇文章 3 订阅

订阅专栏

在这里插入图片描述

一、`GCD`简介

Grand Central Dispatch(GCD) 是 Apple 开发的一个多核编程的较新的解决方法。
它主要用于优化应用程序以支持多核处理器以及其他对称多处理系统。是一个在线程池模式的基础上执行的并发任务

为什么要用 GCD 呢？

GCD 可用于多核的并行运算
GCD 会自动利用更多的 CPU 内核（比如双核、四核）
GCD 会自动管理线程的生命周期（创建线程、调度任务、销毁线程）
程序员只需要告诉GCD想要执行什么任务，不需要编写任何线程管理代码

二、`GCD` 任务和队列

2.1 任务

任务就是执行操作的意思，也就是在线程中所需要执行的那段代码，在GCD中的block中实现。
执行任务分为两种方式: 同步执行 (sync) 和 异步执行 (async)

同步执行

同步添加任务到指定的队列中，在添加的任务执行结束之前，会一直等待，直到队列里面的任务完成之后再继续执行。
只能在当前线程中执行任务，不具备开启新线程的能力。

异步执行

异步添加任务到指定的队列中，它不会做任何等待，可以继续执行任务。
可以在新的线程中执行任务，具备开启新线程的能力。

区别

是否等待队列的任务执行结束，以及是否具备开启新线程的能力

2.2 队列（`Dispatch Queue`）

指执行任务的等待队列，即用来存放任务的队列。

队列是一种特殊的线性表，采用FIFO（先进先出）的原则，即新任务总是被插入到队列的末尾，而读取任务的时候总是从队列的头部开始读取。
每读取一个任务，则从队列中释放一个任务。
在这里插入图片描述
在GCD中有两种队列:

串行队列（Serial Dispatch Queue）

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

并发队列（Concurrent Dispatch Queue）

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

注意：并发队列的并发功能只有在异步（dispatch_async）函数下才有效

区别：

执行顺序不同，以及开启线程数不同

两者具体区别如下两图所示：

在这里插入图片描述

三、`GCD`的使用步骤

GCD 的使用步骤其实很简单，只有两步:

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

3.1 队列的创建和获取

dispatch_queue_create

使用 dispatch_queue_create 来创建队列，需要传入两个参数:

第一个参数表示队列的唯一标识符，用于 DEBUG，可为空，Dispatch Queue 的名称推荐使用应用程序 ID 这种逆序全程域名
第二个参数用来识别是串行队列还是并发队列。DISPATCH_QUEUE_SERIAL 表示串行队列，DISPATCH_QUEUE_CONCURRENT 表示并发队列

方法如下：

// 串行队列的创建方法
dispatch_queue_t queue = dispatch_queue_create("net.gcd.testQueue", DISPATCH_QUEUE_SERIAL);

// 并发队列的创建方法
dispatch_queue_t queue = dispatch_queue_create("net.gcd.testQueue", DISPATCH_QUEUE_CONCURRENT);

主队列（Main Dispatch Queue）

主队列属于GCD中的一种特殊的串行队列，主要有以下特点：

所有放在主队列中的任务，都会放到主线程中执行。
可使用 dispatch_get_main_queue() 获得主队列。

获取方法：

// 主队列的获取方法
dispatch_queue_t queue = dispatch_get_main_queue();

全局并发队列（Global Dispatch Queue）

在并发队列中使用，可以使用dispatch_get_global_queue 来获取。需要传入两个参数:

第一个参数表示队列优先级，一般用DISPATCH_QUEUE_PRIORITY_DEFAULT。
第二个参数暂时没用，用0即可

获取方法：

// 全局并发队列的获取方法
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

3.2 任务的创建方法

GCD 提供了同步执行任务的创建方法dispatch_sync和异步执行任务创建方法dispatch_async

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

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

虽然使用 GCD 只需两步，但是既然我们有两种队列（串行队列/并发队列），两种任务执行方式（同步执行/异步执行），那么我们就有了四种不同的组合方式。这四种不同的组合方式是：

同步执行 + 并发队列
异步执行 + 并发队列
同步执行 + 串行队列
异步执行 + 串行队列

实际上，刚才还说了两种特殊队列：全局并发队列、主队列。全局并发队列可以作为普通并发队列来使用。但是主队列因为有点特殊，所以我们就又多了两种组合方式。这样就有六种不同的组合方式了

同步执行 + 主队列
异步执行 + 主队列

不同组合方式之间的区别:

区别	串行队列	并发队列	主队列
同步(`sync`)	没有开启新线程，串行执行任务	没有开启新线程，串行执行任务	没有开启新线程，串行执行任务
异步(`async`)	有开启新线程(`1`条)，串行执行任务	有开启新线程，并发执行任务	没有开启新线程，串行执行任务

四、`GCD`的基本使用

4.1、同步执行 + 并发队列

在当前线程中执行任务，不会开启新线程，执行完一个任务，再执行下一个任务。

/**
 * 同步执行 + 并发队列
 * 特点：在当前线程中执行任务，不会开启新线程，执行完一个任务，再执行下一个任务。
 */
- (void)syncConcurrentTask{
    NSLog(@"当前线程 : %@",[NSThread currentThread]);
    NSLog(@"syncConcurrentTask : begin");

    dispatch_queue_t queue = dispatch_queue_create("net.gcd.testQueue", DISPATCH_QUEUE_CONCURRENT);
    
    //任务1
    dispatch_sync(queue, ^{
        for (NSInteger index = 0; index < 2; index ++ ) {
            [NSThread sleepForTimeInterval:2];                    // 休眠2s，模拟耗时操作
            NSLog(@"任务1线程: %@",[NSThread currentThread]);      // 打印当前线程
        }
        
    });
    
    //任务2
    dispatch_sync(queue, ^{
        for (NSInteger index = 0; index < 2; index ++ ) {
            [NSThread sleepForTimeInterval:2];                    // 休眠2s，模拟耗时操作
            NSLog(@"任务2线程: %@",[NSThread currentThread]);      // 打印当前线程
        }
        
    });

    //任务3
    dispatch_sync(queue, ^{
        for (NSInteger index = 0; index < 2; index ++ ) {
            [NSThread sleepForTimeInterval:2];                    // 休眠2s，模拟耗时操作
            NSLog(@"任务3线程: %@",[NSThread currentThread]);      // 打印当前线程
        }
    });

    NSLog(@"syncConcurrentTask : end");
}

日志输出:

2019-08-15 11:37:01.882803+0800 XKHttpNetworkHelper[31452:1205128] 当前线程 : <NSThread: 0x600002901300>{number = 1, name = main}
2019-08-15 11:37:01.882926+0800 XKHttpNetworkHelper[31452:1205128] syncConcurrentTask : begin
2019-08-15 11:37:03.883808+0800 XKHttpNetworkHelper[31452:1205128] 任务1线程: <NSThread: 0x600002901300>{number = 1, name = main}
2019-08-15 11:37:05.884233+0800 XKHttpNetworkHelper[31452:1205128] 任务1线程: <NSThread: 0x600002901300>{number = 1, name = main}
2019-08-15 11:37:07.884623+0800 XKHttpNetworkHelper[31452:1205128] 任务2线程: <NSThread: 0x600002901300>{number = 1, name = main}
2019-08-15 11:37:10.057093+0800 XKHttpNetworkHelper[31452:1205128] 任务2线程: <NSThread: 0x600002901300>{number = 1, name = main}
2019-08-15 11:37:12.057729+0800 XKHttpNetworkHelper[31452:1205128] 任务3线程: <NSThread: 0x600002901300>{number = 1, name = main}
2019-08-15 11:37:14.058287+0800 XKHttpNetworkHelper[31452:1205128] 任务3线程: <NSThread: 0x600002901300>{number = 1, name = main}
2019-08-15 11:37:14.058435+0800 XKHttpNetworkHelper[31452:1205128] syncConcurrentTask : end

从执行 (同步执行 + 并发队列) 任务的输出日志中可以看到:

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

4.2、异步执行 + 并发队列

可以开启多个线程，，任务交替(同时)执行

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

日志输出:

2019-08-15 13:53:45.774625+0800 XKHttpNetworkHelper[33086:1319354] 当前线程 : <NSThread: 0x600000712340>{number = 1, name = main}
2019-08-15 13:53:45.774757+0800 XKHttpNetworkHelper[33086:1319354] asyncConcurrentTask : begin
2019-08-15 13:53:45.774857+0800 XKHttpNetworkHelper[33086:1319354] asyncConcurrentTask : end
2019-08-15 13:53:47.778932+0800 XKHttpNetworkHelper[33086:1319430] 任务3线程: <NSThread: 0x60000074c040>{number = 3, name = (null)}
2019-08-15 13:53:47.778932+0800 XKHttpNetworkHelper[33086:1319431] 任务2线程: <NSThread: 0x600000750180>{number = 5, name = (null)}
2019-08-15 13:53:47.778932+0800 XKHttpNetworkHelper[33086:1319432] 任务1线程: <NSThread: 0x600000769000>{number = 4, name = (null)}

2019-08-15 13:53:49.784350+0800 XKHttpNetworkHelper[33086:1319432] 任务1线程: <NSThread: 0x600000769000>{number = 4, name = (null)}
2019-08-15 13:53:49.784341+0800 XKHttpNetworkHelper[33086:1319430] 任务3线程: <NSThread: 0x60000074c040>{number = 3, name = (null)}
2019-08-15 13:53:49.784359+0800 XKHttpNetworkHelper[33086:1319431] 任务2线程: <NSThread: 0x600000750180>{number = 5, name = (null)}

从执行 (异步执行 + 并发队列) 任务的输出日志中可以看到:

除了当前线程（主线程），系统又开启了3个线程，并且任务是交替/同时执行的。（异步执行具备开启新线程的能力。且并发队列可开启多个线程，同时执行多个任务）
所有任务都在打印的asyncConcurrentTask:begin和asyncConcurrentTask:end之后执行的。说明当前线程没有等待，而是直接开启了新线程，在新线程中执行任务(异步执行不必等待，可以继续执行任务)

4.3、同步执行 + 串行队列

不会开启新线程，在当前线程执行任务。任务是串行的，执行完一个任务，再执行下一个任务

/**
 * 同步执行 + 串行队列
 * 特点：不会开启新线程，在当前线程执行任务。任务是串行的，执行完一个任务，再执行下一个任务。
 */
- (void)syncSerialTask{
    NSLog(@"当前线程 : %@",[NSThread currentThread]);
    NSLog(@"syncSerialTask : begin");

    dispatch_queue_t queue = dispatch_queue_create("net.gcd.testQueue", DISPATCH_QUEUE_SERIAL);
    
    //任务1
    dispatch_sync(queue, ^{
        for (NSInteger index = 0; index < 2; index ++ ) {
            [NSThread sleepForTimeInterval:2];                    // 休眠2s，模拟耗时操作
            NSLog(@"任务1线程: %@",[NSThread currentThread]);      // 打印当前线程
        }
        
    });
    
    //任务2
    dispatch_sync(queue, ^{
        for (NSInteger index = 0; index < 2; index ++ ) {
            [NSThread sleepForTimeInterval:2];                    // 休眠2s，模拟耗时操作
            NSLog(@"任务2线程: %@",[NSThread currentThread]);      // 打印当前线程
        }
        
    });

    //任务3
    dispatch_sync(queue, ^{
        for (NSInteger index = 0; index < 2; index ++ ) {
            [NSThread sleepForTimeInterval:2];                    // 休眠2s，模拟耗时操作
            NSLog(@"任务3线程: %@",[NSThread currentThread]);      // 打印当前线程
        }
    });

    NSLog(@"syncSerialTask : end");
}

日志输出:

2019-08-15 14:17:24.193189+0800 XKHttpNetworkHelper[33428:1377743] 当前线程 : <NSThread: 0x6000009c1480>{number = 1, name = main}
2019-08-15 14:17:24.193313+0800 XKHttpNetworkHelper[33428:1377743] syncSerialTask : begin
2019-08-15 14:17:26.194075+0800 XKHttpNetworkHelper[33428:1377743] 任务1线程: <NSThread: 0x6000009c1480>{number = 1, name = main}
2019-08-15 14:17:28.194587+0800 XKHttpNetworkHelper[33428:1377743] 任务1线程: <NSThread: 0x6000009c1480>{number = 1, name = main}
2019-08-15 14:17:30.195848+0800 XKHttpNetworkHelper[33428:1377743] 任务2线程: <NSThread: 0x6000009c1480>{number = 1, name = main}
2019-08-15 14:17:32.196502+0800 XKHttpNetworkHelper[33428:1377743] 任务2线程: <NSThread: 0x6000009c1480>{number = 1, name = main}
2019-08-15 14:17:34.196834+0800 XKHttpNetworkHelper[33428:1377743] 任务3线程: <NSThread: 0x6000009c1480>{number = 1, name = main}
2019-08-15 14:17:36.197151+0800 XKHttpNetworkHelper[33428:1377743] 任务3线程: <NSThread: 0x6000009c1480>{number = 1, name = main}
2019-08-15 14:17:36.197387+0800 XKHttpNetworkHelper[33428:1377743] syncSerialTask : end

从执行 (同步执行 + 串行队列) 任务的输出日志中可以看到:

所有任务都是在当前线程（主线程）中执行的，并没有开启新的线程（同步执行不具备开启新线程的能力）。
所有任务都在打印的syncSerialTask:begin和syncSerialTask:end之间执行（同步任务需要等待队列的任务执行结束）。
任务是按顺序执行的（串行队列每次只有一个任务被执行，任务一个接一个按顺序执行）。

4.4、异步执行 + 串行队列

会开启新线程，但是因为任务是串行的，执行完一个任务，再执行下一个任务

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

日志输出:

2019-08-15 14:23:59.070912+0800 XKHttpNetworkHelper[33542:1394792] 当前线程 : <NSThread: 0x600002554d00>{number = 1, name = main}
2019-08-15 14:23:59.071072+0800 XKHttpNetworkHelper[33542:1394792] asyncSerialTask : begin
2019-08-15 14:23:59.071207+0800 XKHttpNetworkHelper[33542:1394792] asyncSerialTask : end
2019-08-15 14:24:01.076086+0800 XKHttpNetworkHelper[33542:1394881] 任务1线程: <NSThread: 0x60000251b9c0>{number = 3, name = (null)}
2019-08-15 14:24:03.080528+0800 XKHttpNetworkHelper[33542:1394881] 任务1线程: <NSThread: 0x60000251b9c0>{number = 3, name = (null)}
2019-08-15 14:24:05.085977+0800 XKHttpNetworkHelper[33542:1394881] 任务2线程: <NSThread: 0x60000251b9c0>{number = 3, name = (null)}
2019-08-15 14:24:07.091084+0800 XKHttpNetworkHelper[33542:1394881] 任务2线程: <NSThread: 0x60000251b9c0>{number = 3, name = (null)}
2019-08-15 14:24:09.094797+0800 XKHttpNetworkHelper[33542:1394881] 任务3线程: <NSThread: 0x60000251b9c0>{number = 3, name = (null)}
2019-08-15 14:24:11.097145+0800 XKHttpNetworkHelper[33542:1394881] 任务3线程: <NSThread: 0x60000251b9c0>{number = 3, name = (null)}

从执行 (异步执行 + 串行队列) 任务的输出日志中可以看到:

开启了一条新线程（异步执行具备开启新线程的能力，串行队列只开启一个线程）。
所有任务是在打印的asyncSerialTask:begin和asyncSerialTask:end之后才开始执行的（异步执行不会做任何等待，可以继续执行任务）。
任务是按顺序执行的（串行队列每次只有一个任务被执行，任务一个接一个按顺序执行）。

4.5、同步执行 + 主队列

主队列: GCD自带的一种特殊的串行队列

所有放在主队列中的任务，都会放到主线程中执行
可使用dispatch_get_main_queue()获得主队列

注意:

同步执行 + 主队列在不同线程中调用结果也是不一样，在主线程中调用会出现死锁，而在其他线程中则不会。
在这里做一个解释，导致死锁的原因，是在同一个串行队列任务中，两个任务相互依赖所导致的，并不局限于同步执行 + 主队列的模式，在这里只是举例说明。

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

互相等待卡住不可行

/**
 * 同步执行 + 主队列
 * 特点(主线程调用)：互等卡主不执行。
 * 特点(其他线程调用)：不会开启新线程，执行完一个任务，再执行下一个任务。
 */
- (void)syncMainTask{
    NSLog(@"当前线程 : %@",[NSThread currentThread]);
    NSLog(@"syncMainTask : begin");

    dispatch_queue_t queue = dispatch_get_main_queue();
    
    //任务1
    dispatch_sync(queue, ^{
        for (NSInteger index = 0; index < 2; index ++ ) {
            [NSThread sleepForTimeInterval:2];                    // 休眠2s，模拟耗时操作
            NSLog(@"任务1线程: %@",[NSThread currentThread]);      // 打印当前线程
        }
        
    });
    
    //任务2
    dispatch_sync(queue, ^{
        for (NSInteger index = 0; index < 2; index ++ ) {
            [NSThread sleepForTimeInterval:2];                    // 休眠2s，模拟耗时操作
            NSLog(@"任务2线程: %@",[NSThread currentThread]);      // 打印当前线程
        }
        
    });

    //任务3
    dispatch_sync(queue, ^{
        for (NSInteger index = 0; index < 2; index ++ ) {
            [NSThread sleepForTimeInterval:2];                    // 休眠2s，模拟耗时操作
            NSLog(@"任务3线程: %@",[NSThread currentThread]);      // 打印当前线程
        }
    });

    NSLog(@"syncMainTask : end");
}

日志输出:

2019-08-15 14:30:36.746214+0800 XKHttpNetworkHelper[33641:1411969] 当前线程 : <NSThread: 0x6000013d40c0>{number = 1, name = main}
2019-08-15 14:30:36.746396+0800 XKHttpNetworkHelper[33641:1411969] syncMainTask : begin
(lldb)

从主线程执行 (同步执行 + 主队列) 任务的输出日志中可以看到:

在主线程中使用同步执行 + 主队列，追加到主线程的任务1、任务2、任务3都不再执行了，syncMainTask:end也没有打印

于此同时，在Xcode上执行该代码时，还会出现崩溃，这是为什么呢?

答: 当在主线程中执行syncMainTask方法，相当于把syncMainTask 任务放到了主线程的队列中。而同步执行会等待当前队列中的任务执行完毕，才会接着执行下一个任务。
那么当把任务1追加到主队列中，任务1就在等待主线程处理syncMainTask任务，而syncMainTask任务需要等待任务1执行完毕，才会接着执行。
那么，当syncMainTask任务和任务1都在等待对方执行完毕，这就导致了线程卡住了，队列中的任务也执行不了，所以也没有打印syncMainTask:end

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

不会开启新线程，执行完一个任务，再执行下一个任务。

// 使用 NSThread 的 detachNewThreadSelector 方法会创建线程，并自动启动线程执行

[NSThread detachNewThreadSelector:@selector(syncMainTask) toTarget:self withObject:nil];

日志输出: 

2019-08-15 14:38:37.113023+0800 XKHttpNetworkHelper[33757:1426643] 当前线程 : <NSThread: 0x600001269280>{number = 3, name = (null)}
2019-08-15 14:38:37.113231+0800 XKHttpNetworkHelper[33757:1426643] syncMainTask : begin
2019-08-15 14:38:39.124858+0800 XKHttpNetworkHelper[33757:1426494] 任务1线程: <NSThread: 0x600001216900>{number = 1, name = main}
2019-08-15 14:38:41.125326+0800 XKHttpNetworkHelper[33757:1426494] 任务1线程: <NSThread: 0x600001216900>{number = 1, name = main}
2019-08-15 14:38:43.127719+0800 XKHttpNetworkHelper[33757:1426494] 任务2线程: <NSThread: 0x600001216900>{number = 1, name = main}
2019-08-15 14:38:45.128980+0800 XKHttpNetworkHelper[33757:1426494] 任务2线程: <NSThread: 0x600001216900>{number = 1, name = main}
2019-08-15 14:38:47.131208+0800 XKHttpNetworkHelper[33757:1426494] 任务3线程: <NSThread: 0x600001216900>{number = 1, name = main}
2019-08-15 14:38:49.131635+0800 XKHttpNetworkHelper[33757:1426494] 任务3线程: <NSThread: 0x600001216900>{number = 1, name = main}
2019-08-15 14:38:49.132000+0800 XKHttpNetworkHelper[33757:1426643] syncMainTask : end

从其他线程执行 (同步执行 + 主队列) 任务的输出日志中可以看到:

所有任务都是在主线程（非当前线程）中执行的，没有开启新的线程（所有放在主队列中的任务，都会放到主线程中执行）。
所有任务都在打印的syncMainTask:begin和syncMainTask:end之间执行（同步任务需要等待队列的任务执行结束）。
任务是按顺序执行的（主队列是串行队列，每次只有一个任务被执行，任务一个接一个按顺序执行）。

为什么在其他线程执行，就不会卡住了呢？

答：因为 syncMainTask 放到了其他线程里，而任务1、任务2、任务3都追加在主队列中，这三个任务都会在主线程中执行。
syncMainTask任务在其他线程中执行追加到任务1到队列中，因为主队列现在没有正在执行的任务，
所以，会直接执行主队列的任务1，等任务1执行完毕，再接着执行任务2、任务3。所以这里不会卡住线程。

4.6、异步执行 + 主队列

只在主线程中执行任务，执行完一个任务，再执行下一个任务。

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

日志输出：


2019-08-15 14:47:20.946679+0800 XKHttpNetworkHelper[33880:1443430] 当前线程 : <NSThread: 0x6000031a0c40>{number = 1, name = main}
2019-08-15 14:47:20.946835+0800 XKHttpNetworkHelper[33880:1443430] asyncMainTask : begin
2019-08-15 14:47:20.946933+0800 XKHttpNetworkHelper[33880:1443430] asyncMainTask : end
2019-08-15 14:47:22.961664+0800 XKHttpNetworkHelper[33880:1443430] 任务1线程: <NSThread: 0x6000031a0c40>{number = 1, name = main}
2019-08-15 14:47:24.961989+0800 XKHttpNetworkHelper[33880:1443430] 任务1线程: <NSThread: 0x6000031a0c40>{number = 1, name = main}
2019-08-15 14:47:26.962337+0800 XKHttpNetworkHelper[33880:1443430] 任务2线程: <NSThread: 0x6000031a0c40>{number = 1, name = main}
2019-08-15 14:47:28.962802+0800 XKHttpNetworkHelper[33880:1443430] 任务2线程: <NSThread: 0x6000031a0c40>{number = 1, name = main}
2019-08-15 14:47:30.964399+0800 XKHttpNetworkHelper[33880:1443430] 任务3线程: <NSThread: 0x6000031a0c40>{number = 1, name = main}
2019-08-15 14:47:32.965105+0800 XKHttpNetworkHelper[33880:1443430] 任务3线程: <NSThread: 0x6000031a0c40>{number = 1, name = main}

从执行 (异步执行 + 主队列) 任务的输出日志中可以看到:

所有任务都是在当前线程（主线程）中执行的，并没有开启新的线程（虽然异步执行具备开启线程的能力，但因为是主队列，所以所有任务都在主线程中）。
所有任务是在打印的syncConcurrent---begin和syncConcurrent---end之后才开始执行的（异步执行不会做任何等待，可以继续执行任务）。
任务是按顺序执行的（因为主队列是串行队列，每次只有一个任务被执行，任务一个接一个按顺序执行）。

五、`GCD`线程间的通信

在 iOS 开发过程中，我们一般在主线程里边进行 UI 刷新，例如：点击、滚动、拖拽等事件。我们通常把一些耗时的操作放在其他线程，比如说图片下载、文件上传等耗时操作。而当我们有时候在其他线程完成了耗时操作时，需要回到主线程，那么就用到了线程之间的通讯。

/**
 * 线程间通信
 */
- (void)reloadDatas{
    // 获取全局并发队列
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    
    // 获取主队列
    dispatch_queue_t mainQueue = dispatch_get_main_queue();
    
    dispatch_async(queue, ^{
        //异步处理一些耗时操作的数据
        
        for (NSInteger index = 0; index < 2; index ++ ) {
            [NSThread sleepForTimeInterval:2];                    // 休眠2s，模拟耗时操作
            NSLog(@"异步线程: %@",[NSThread currentThread]);       // 打印当前线程
        }
        
        dispatch_async(mainQueue, ^{
            //主线程，更新UI等等
            
            [NSThread sleepForTimeInterval:2];                    // 休眠2s，模拟耗时操作
            NSLog(@"主线程: %@",[NSThread currentThread]);       // 打印当前线程
        });
    });
}

日志输出: 

2019-08-15 14:53:19.932779+0800 XKHttpNetworkHelper[33980:1459145] 异步线程: <NSThread: 0x600002500240>{number = 3, name = (null)}
2019-08-15 14:53:21.937532+0800 XKHttpNetworkHelper[33980:1459145] 异步线程: <NSThread: 0x600002500240>{number = 3, name = (null)}
2019-08-15 14:53:23.937934+0800 XKHttpNetworkHelper[33980:1459058] 主线程: <NSThread: 0x600002572940>{number = 1, name = main}

从执行任务的结果上看:

可以看到在其他线程中先执行任务，执行完了之后回到主线程执行主线程的相应操作。

六、`GCD` 的特殊方法

6.1 栅栏方法: `dispatch_barrier_async`

在日常开发过程中，有时候需要异步执行两组操作，而且第一组操作执行完之后，才能开始执行第二组操作。这样我们就需要一个相当于栅栏一样的一个方法将两组异步执行的操作组给分割起来，当然这里的操作组里可以包含一个或多个任务。这就需要用到 dispatch_barrier_async 方法在两个操作组间形成栅栏。

dispatch_barrier_async 函数会等待前边追加到并发队列中的任务全部执行完毕之后，再将指定的任务追加到该异步队列中。
后在 dispatch_barrier_async 函数追加的任务执行完毕之后，异步队列才恢复为一般动作，接着追加任务到该异步队列并开始执行。

/**
 * 栅栏方法
 */
- (void)barrierAsyncTask{
    NSLog(@"当前线程 : %@",[NSThread currentThread]);
    NSLog(@"barrierAsyncTask : begin");
    
    dispatch_queue_t queue = dispatch_queue_create("net.gcd.testQueue", DISPATCH_QUEUE_CONCURRENT);
    
    //任务1
    dispatch_async(queue, ^{
        for (NSInteger index = 0; index < 2; index ++ ) {
            [NSThread sleepForTimeInterval:2];                    // 休眠2s，模拟耗时操作
            NSLog(@"任务1线程: %@",[NSThread currentThread]);      // 打印当前线程
        }
        
    });
    
    //任务2
    dispatch_async(queue, ^{
        for (NSInteger index = 0; index < 2; index ++ ) {
            [NSThread sleepForTimeInterval:2];                    // 休眠2s，模拟耗时操作
            NSLog(@"任务2线程: %@",[NSThread currentThread]);      // 打印当前线程
        }
    });
    
    //栅栏方法
    dispatch_barrier_async(queue, ^{
        for (NSInteger index = 0; index < 2; index ++ ) {
            [NSThread sleepForTimeInterval:2];                    // 休眠2s，模拟耗时操作
            NSLog(@"栅栏方法 barrier: %@",[NSThread currentThread]);      // 打印当前线程
        }
    });
    
    
    //任务3
    dispatch_async(queue, ^{
        for (NSInteger index = 0; index < 2; index ++ ) {
            [NSThread sleepForTimeInterval:2];                    // 休眠2s，模拟耗时操作
            NSLog(@"任务3线程: %@",[NSThread currentThread]);      // 打印当前线程
        }
    });
    
    //任务4
    dispatch_async(queue, ^{
        for (NSInteger index = 0; index < 2; index ++ ) {
            [NSThread sleepForTimeInterval:2];                    // 休眠2s，模拟耗时操作
            NSLog(@"任务4线程: %@",[NSThread currentThread]);      // 打印当前线程
        }
    });
    NSLog(@"barrierAsyncTask : end");
}


日志输出:

2019-08-16 10:19:29.248058+0800 XKHttpNetworkHelper[1243:102722] 当前线程 : <NSThread: 0x6000016929c0>{number = 1, name = main}
2019-08-16 10:19:29.248226+0800 XKHttpNetworkHelper[1243:102722] barrierAsyncTask : begin
2019-08-16 10:19:29.248329+0800 XKHttpNetworkHelper[1243:102722] barrierAsyncTask : end
2019-08-16 10:19:31.252557+0800 XKHttpNetworkHelper[1243:103201] 任务1线程: <NSThread: 0x6000016c0080>{number = 3, name = (null)}
2019-08-16 10:19:31.252557+0800 XKHttpNetworkHelper[1243:103203] 任务2线程: <NSThread: 0x6000016fbc00>{number = 4, name = (null)}
2019-08-16 10:19:33.256810+0800 XKHttpNetworkHelper[1243:103203] 任务2线程: <NSThread: 0x6000016fbc00>{number = 4, name = (null)}
2019-08-16 10:19:33.256827+0800 XKHttpNetworkHelper[1243:103201] 任务1线程: <NSThread: 0x6000016c0080>{number = 3, name = (null)}

2019-08-16 10:19:35.260173+0800 XKHttpNetworkHelper[1243:103203] 栅栏方法 barrier: <NSThread: 0x6000016fbc00>{number = 4, name = (null)}
2019-08-16 10:19:37.262588+0800 XKHttpNetworkHelper[1243:103203] 栅栏方法 barrier: <NSThread: 0x6000016fbc00>{number = 4, name = (null)}

2019-08-16 10:19:39.266496+0800 XKHttpNetworkHelper[1243:103201] 任务4线程: <NSThread: 0x6000016c0080>{number = 3, name = (null)}
2019-08-16 10:19:39.266509+0800 XKHttpNetworkHelper[1243:103203] 任务3线程: <NSThread: 0x6000016fbc00>{number = 4, name = (null)}
2019-08-16 10:19:41.271556+0800 XKHttpNetworkHelper[1243:103203] 任务3线程: <NSThread: 0x6000016fbc00>{number = 4, name = (null)}
2019-08-16 10:19:41.271556+0800 XKHttpNetworkHelper[1243:103201] 任务4线程: <NSThread: 0x6000016c0080>{number = 3, name = (null)}

从执行任务的输出日志中可以看到:

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

6.2 延时方法: `dispatch_after`

在一些日常的开发任务中，会遇到这样的需求: 在指定时间(例如3秒)之后执行某个任务。可以用 dispatch_after 函数来实现。需要注意的是：

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

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

日志输出:

2019-08-16 10:32:09.909632+0800 XKHttpNetworkHelper[1406:131070] 当前线程 : <NSThread: 0x600003b32940>{number = 1, name = main}
2019-08-16 10:32:09.909756+0800 XKHttpNetworkHelper[1406:131070] afterTask : begin
2019-08-16 10:32:09.909846+0800 XKHttpNetworkHelper[1406:131070] afterTask : end

//间隔2后才打印
2019-08-16 10:32:12.105720+0800 XKHttpNetworkHelper[1406:131070] 延时任务: <NSThread: 0x600003b32940>{number = 1, name = main}

6.3 一次性代码（只执行一次）: `dispatch_once`

在实现单例创建或者整个程序运行过程只执行一次的代码时，就可以使用到 dispatch_once 函数。

使用 dispatch_once 函数能保证某段代码在程序运行过程中只被执行一次，并且即使多线程的环境下，dispatch_once 也可以保证线程安全

/**
 * 一次性代码（只执行一次）dispatch_once
 */
- (void)onceTask{
    static dispatch_once_t onceToken ;
    dispatch_once(&onceToken, ^{
         // 只执行1次的代码(这里面默认是线程安全的)
    });
}

6.4 快速迭代方法: `dispatch_apply`

通常情况下，回使用for循环遍历，但是GCD提供了快速迭代的方法 dispatch_apply

dispatch_apply按照指定的次数将指定的任务追加到指定的队列中，并等待全部队列执行结束。

还可以利用异步队列同时遍历，例如：遍历0-5 这6个数字，for循环的做法是每次取出一个元素，逐个遍历。而dispatch_apply 可以同时遍历多个数字

/**
 *  快速迭代方法 dispatch_apply
 */
- (void)applyTask{
    NSLog(@"applyTask : begin");
    
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    dispatch_apply(6, queue, ^(size_t index) {
        NSLog(@"applyTask -- %ld: %@",index,[NSThread currentThread]);  // 打印当前线程
    });
    NSLog(@"applyTask : end");
}

日志输出: 

2019-08-16 14:09:49.328469+0800 XKHttpNetworkHelper[17064:389593] applyTask : begin
2019-08-16 14:09:49.328685+0800 XKHttpNetworkHelper[17064:389662] applyTask -- 1: <NSThread: 0x600001d9ca80>{number = 3, name = (null)}
2019-08-16 14:09:49.328702+0800 XKHttpNetworkHelper[17064:389593] applyTask -- 0: <NSThread: 0x600001ded480>{number = 1, name = main}
2019-08-16 14:09:49.328708+0800 XKHttpNetworkHelper[17064:389677] applyTask -- 5: <NSThread: 0x600001daa300>{number = 5, name = (null)}
2019-08-16 14:09:49.328711+0800 XKHttpNetworkHelper[17064:389675] applyTask -- 4: <NSThread: 0x600001db8100>{number = 4, name = (null)}
2019-08-16 14:09:49.328718+0800 XKHttpNetworkHelper[17064:389680] applyTask -- 3: <NSThread: 0x600001d83680>{number = 7, name = (null)}
2019-08-16 14:09:49.328723+0800 XKHttpNetworkHelper[17064:389676] applyTask -- 2: <NSThread: 0x600001db80c0>{number = 6, name = (null)}
2019-08-16 14:09:49.328862+0800 XKHttpNetworkHelper[17064:389593] applyTask : end

从执行任务的输出日志中可以看到:

使用dispatch_apply遍历的过程中，日志输出打印的结果顺序不定，但 applyTask : end 是在最后才执行的

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

6.5 队列组: `dispatch_group`

在日常开发过程中，可能回遇到类似于这样的需求: 分别异步执行2个耗时任务，然后当2个耗时任务都执行完毕后再回到主线程执行任务。比如“多任务下载列表” ，对于这种情况的处理，我们可以使用 GCD的队列组。

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

6.5.1 `dispatch_group_notify`

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

/**
 * 队列组 dispatch_group_notify
 */
- (void)asyncGroupTask{
    NSLog(@"当前线程 : %@",[NSThread currentThread]);
    NSLog(@"asyncGroupTask : begin");
    
    dispatch_group_t group = dispatch_group_create();
    
    //任务1
    dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        for (NSInteger index = 0; index < 2; index ++ ) {
            [NSThread sleepForTimeInterval:2];                    // 休眠2s，模拟耗时操作
            NSLog(@"任务1线程: %@",[NSThread currentThread]);      // 打印当前线程
        }
    });
    
    //任务2
    dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        for (NSInteger index = 0; index < 2; index ++ ) {
            [NSThread sleepForTimeInterval:2];                    // 休眠2s，模拟耗时操作
            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(@"主线程: %@",[NSThread currentThread]);      // 打印当前线程
        }
        NSLog(@"asyncGroupTask : end");
    });
}

日志输出: 

2019-08-16 14:24:29.498165+0800 XKHttpNetworkHelper[17285:415433] 当前线程 : <NSThread: 0x600003d8a940>{number = 1, name = main}
2019-08-16 14:24:29.498303+0800 XKHttpNetworkHelper[17285:415433] asyncGroupTask : begin
2019-08-16 14:24:31.500079+0800 XKHttpNetworkHelper[17285:415495] 任务1线程: <NSThread: 0x600003de1dc0>{number = 4, name = (null)}
2019-08-16 14:24:31.500080+0800 XKHttpNetworkHelper[17285:415502] 任务2线程: <NSThread: 0x600003dd4380>{number = 3, name = (null)}
2019-08-16 14:24:33.502466+0800 XKHttpNetworkHelper[17285:415495] 任务1线程: <NSThread: 0x600003de1dc0>{number = 4, name = (null)}
2019-08-16 14:24:33.502506+0800 XKHttpNetworkHelper[17285:415502] 任务2线程: <NSThread: 0x600003dd4380>{number = 3, name = (null)}
2019-08-16 14:24:35.502939+0800 XKHttpNetworkHelper[17285:415433] 主线程: <NSThread: 0x600003d8a940>{number = 1, name = main}
2019-08-16 14:24:37.503722+0800 XKHttpNetworkHelper[17285:415433] 主线程: <NSThread: 0x600003d8a940>{number = 1, name = main}
2019-08-16 14:24:37.503999+0800 XKHttpNetworkHelper[17285:415433] asyncGroupTask : end

从执行任务的输出日志中可以看到:

当所有任务都执行完成之后，才执行dispatch_group_notify block 中的任务。

6.5.2 `dispatch_group_wait`

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

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

日志输出: 

2019-08-19 09:56:49.433832+0800 XKHttpNetworkHelper[1752:316226] 当前线程 : <NSThread: 0x600003c7e900>{number = 1, name = main}
2019-08-19 09:56:49.434004+0800 XKHttpNetworkHelper[1752:316226] asyncGroupWaitTask : begin
2019-08-19 09:56:51.437733+0800 XKHttpNetworkHelper[1752:316342] 任务2线程: <NSThread: 0x600003c26e40>{number = 4, name = (null)}
2019-08-19 09:56:51.437754+0800 XKHttpNetworkHelper[1752:316341] 任务1线程: <NSThread: 0x600003c20140>{number = 3, name = (null)}
2019-08-19 09:56:53.439997+0800 XKHttpNetworkHelper[1752:316341] 任务1线程: <NSThread: 0x600003c20140>{number = 3, name = (null)}
2019-08-19 09:56:53.440009+0800 XKHttpNetworkHelper[1752:316342] 任务2线程: <NSThread: 0x600003c26e40>{number = 4, name = (null)}
2019-08-19 09:56:53.440181+0800 XKHttpNetworkHelper[1752:316226] asyncGroupWaitTask : end


//去除dispatch_group_wait后的日志:

2019-08-19 09:58:26.873803+0800 XKHttpNetworkHelper[1855:321884] 当前线程 : <NSThread: 0x600003fd97c0>{number = 1, name = main}
2019-08-19 09:58:26.873944+0800 XKHttpNetworkHelper[1855:321884] asyncGroupWaitTask : begin
2019-08-19 09:58:26.874078+0800 XKHttpNetworkHelper[1855:321884] asyncGroupWaitTask : end
2019-08-19 09:58:28.877712+0800 XKHttpNetworkHelper[1855:322057] 任务1线程: <NSThread: 0x600003fa55c0>{number = 3, name = (null)}
2019-08-19 09:58:28.877736+0800 XKHttpNetworkHelper[1855:322065] 任务2线程: <NSThread: 0x600003f82fc0>{number = 4, name = (null)}
2019-08-19 09:58:30.880441+0800 XKHttpNetworkHelper[1855:322065] 任务2线程: <NSThread: 0x600003f82fc0>{number = 4, name = (null)}
2019-08-19 09:58:30.880441+0800 XKHttpNetworkHelper[1855:322057] 任务1线程: <NSThread: 0x600003fa55c0>{number = 3, name = (null)}

从执行任务的输出日志中可以看到:

当所有任务执行完成之后，才执行 dispatch_group_wait 之后的操作。但是，使用dispatch_group_wait 会阻塞当前线程

6.5.3 `dispatch_group_enter`、`dispatch_group_leave`

dispatch_group_enter 标志着一个任务追加到 group，执行一次，相当于 group 中未执行完毕任务数+1
dispatch_group_leave 标志着一个任务离开了 group，执行一次，相当于 group 中未执行完毕任务数-1。
当 group 中未执行完毕任务数为0的时候，才会使dispatch_group_wait解除阻塞，以及执行追加到dispatch_group_notify中的任务

/**
 * 队列组 dispatch_group_enter、dispatch_group_leave
 */
- (void)asyncGroupEnterAndLeaveTask{
    NSLog(@"当前线程 : %@",[NSThread currentThread]);
    NSLog(@"asyncGroupEnterAndLeaveTask : begin");
    
    dispatch_group_t group = dispatch_group_create();
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

    //任务1
    dispatch_group_enter(group);
    dispatch_async(queue, ^{
        for (NSInteger index = 0; index < 2; index ++ ) {
            [NSThread sleepForTimeInterval:2];                    // 休眠2s，模拟耗时操作
            NSLog(@"任务1线程: %@",[NSThread currentThread]);      // 打印当前线程
        }
        dispatch_group_leave(group);
    });
    
    //任务2
    dispatch_group_enter(group);
    dispatch_async(queue, ^{
        for (NSInteger index = 0; index < 2; index ++ ) {
            [NSThread sleepForTimeInterval:2];                    // 休眠2s，模拟耗时操作
            NSLog(@"任务2线程: %@",[NSThread currentThread]);      // 打印当前线程
        }
        dispatch_group_leave(group);
    });
    
    dispatch_group_notify(group, dispatch_get_main_queue(), ^{
        // 等前面的异步任务1、任务2都执行完毕后，回到主线程执行下边任务
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
            NSLog(@"主线程: %@",[NSThread currentThread]);      // 打印当前线程
        }
        NSLog(@"asyncGroupEnterAndLeaveTask : end");
    });
}

//日志输出: 

2019-08-19 10:43:30.184976+0800 XKHttpNetworkHelper[19410:485864] 当前线程 : <NSThread: 0x6000008fe3c0>{number = 1, name = main}
2019-08-19 10:43:30.185190+0800 XKHttpNetworkHelper[19410:485864] asyncGroupEnterAndLeaveTask : begin
2019-08-19 10:43:32.189332+0800 XKHttpNetworkHelper[19410:486006] 任务1线程: <NSThread: 0x600000885400>{number = 4, name = (null)}
2019-08-19 10:43:32.189332+0800 XKHttpNetworkHelper[19410:486008] 任务2线程: <NSThread: 0x600000888000>{number = 3, name = (null)}
2019-08-19 10:43:34.192766+0800 XKHttpNetworkHelper[19410:486008] 任务2线程: <NSThread: 0x600000888000>{number = 3, name = (null)}
2019-08-19 10:43:34.192766+0800 XKHttpNetworkHelper[19410:486006] 任务1线程: <NSThread: 0x600000885400>{number = 4, name = (null)}
2019-08-19 10:43:36.193189+0800 XKHttpNetworkHelper[19410:485864] 主线程: <NSThread: 0x6000008fe3c0>{number = 1, name = main}
2019-08-19 10:43:38.193421+0800 XKHttpNetworkHelper[19410:485864] 主线程: <NSThread: 0x6000008fe3c0>{number = 1, name = main}
2019-08-19 10:43:38.193560+0800 XKHttpNetworkHelper[19410:485864] asyncGroupEnterAndLeaveTask : end

从执行任务的输出日志中可以看到:

当所有任务执行完成之后，才执行 dispatch_group_notify 中的任务。这里的dispatch_group_enter、dispatch_group_leave组合，其实等同于dispatch_group_async

6.6 信号量: `dispatch_semaphore`

GCD 中的信号量是指 Dispatch Semaphore ，是持有计数的信号。类似于一个高速路收费站的栏杆。可以通过时，打开栏杆，不可以通过时，关闭栏杆。

在 Dispatch Semaphore 中，使用计数来完成这个功能，计数为0时等待，不可通过。计数为1或大于1时，计数减1且不等待，可通过。

Dispatch Semaphore 提供了三个函数:

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

注意:

信号量的使用前提是：想清楚你需要处理哪个线程等待（阻塞），又要哪个线程继续执行，然后使用信号量。

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

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

6.6.1 `Dispatch` `Semaphore` 线程同步

在日常开发任务中，会有这样的需求: 异步执行耗时任务，并使用异步执行的结果进行一些额外的操作。换句话说，相当于将异步执行任务转换为同步执行任务。

比如说：AFNetworking 中 AFURLSessionManager.m 里面的 tasksForKeyPath: 方法。通过引入信号量的方式，等待异步执行任务结果，获取到 tasks，然后再返回该 tasks。

- (NSArray *)tasksForKeyPath:(NSString *)keyPath {
    __block NSArray *tasks = nil;
    dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
    [self.session getTasksWithCompletionHandler:^(NSArray *dataTasks, NSArray *uploadTasks, NSArray *downloadTasks) {
        if ([keyPath isEqualToString:NSStringFromSelector(@selector(dataTasks))]) {
            tasks = dataTasks;
        } else if ([keyPath isEqualToString:NSStringFromSelector(@selector(uploadTasks))]) {
            tasks = uploadTasks;
        } else if ([keyPath isEqualToString:NSStringFromSelector(@selector(downloadTasks))]) {
            tasks = downloadTasks;
        } else if ([keyPath isEqualToString:NSStringFromSelector(@selector(tasks))]) {
            tasks = [@[dataTasks, uploadTasks, downloadTasks] valueForKeyPath:@"@unionOfArrays.self"];
        }

        dispatch_semaphore_signal(semaphore);
    }];

    dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);

    return tasks;
}

下面，我们来利用 Dispatch Semaphore 实现线程同步，将异步执行任务转换为同步执行任务。

/**
 * 信号量 dispatch_semaphore
 */
- (void)asyncSemaphoreTask {
    NSLog(@"当前线程 : %@",[NSThread currentThread]);
    NSLog(@"asyncSemaphoreTask : begin");
    
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);


    __block NSInteger number = 0;
    dispatch_async(queue, ^{
        for (NSInteger index = 0; index < 2; index ++ ) {
            [NSThread sleepForTimeInterval:2];                    // 休眠2s，模拟耗时操作
            NSLog(@"任务1线程: %@",[NSThread currentThread]);      // 打印当前线程
        }
        
        number = 100;
        dispatch_semaphore_signal(semaphore);
    });
    dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
    NSLog(@"asyncSemaphoreTask: end,number = %zd",number);
}

日志输出:

2019-08-19 11:20:40.118988+0800 XKHttpNetworkHelper[20027:564696] 当前线程 : <NSThread: 0x600001490cc0>{number = 1, name = main}
2019-08-19 11:20:40.119158+0800 XKHttpNetworkHelper[20027:564696] asyncSemaphoreTask : begin
2019-08-19 11:20:42.123825+0800 XKHttpNetworkHelper[20027:564811] 任务1线程: <NSThread: 0x6000014c2640>{number = 3, name = (null)}
2019-08-19 11:20:44.128749+0800 XKHttpNetworkHelper[20027:564811] 任务1线程: <NSThread: 0x6000014c2640>{number = 3, name = (null)}
2019-08-19 11:20:44.128909+0800 XKHttpNetworkHelper[20027:564696] asyncSemaphoreTask: end,number = 100

从执行任务的输出日志中可以看到:

semaphore---end 是在执行完 number = 100; 之后才打印的。而且输出结果 number 为 100。这是因为异步执行不会做任何等待，可以继续执行任务。
异步执行将任务1追加到队列之后，不做等待，接着执行dispatch_semaphore_wait方法。此时 semaphore == 0，当前线程进入等待状态。然后，异步任务1开始执行。任务1执行到dispatch_semaphore_signal之后，总信号量，此时 semaphore == 1，dispatch_semaphore_wait方法使总信号量减1，正在被阻塞的线程（主线程）恢复继续执行。
最后打印 asyncSemaphoreTask: end,number = 100。这样就实现了线程同步，将异步执行任务转换为同步执行任务。

6.6.2 `Dispatch` `Semaphore` 线程安全和线程同步（为线程加锁）

线程安全:

如果你的代码所在的进程中有多个线程在同时运行，而这些线程可能会同时运行这段代码。如果每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。
若每个线程中对全局变量、静态变量只有读操作，而无写操作，一般来说，这个全局变量是线程安全的；若有多个线程同时执行写操作（更改变量），一般都需要考虑线程同步，否则的话就可能影响线程安全。

线程同步:

可理解为线程 A 和线程 B 一块配合，A 执行到一定程度时要依靠线程 B 的某个结果，于是停下来，示意 B 运行；B 依言执行，再将结果给 A；A 再继续操作。

举个简单例子就是：两个人在一起聊天。两个人不能同时说话，避免听不清(操作冲突)。等一个人说完(一个线程结束操作)，另一个再说(另一个线程再开始操作)。

场景模拟:

模拟火车票售卖的方式，实现 NSThread 线程安全和解决线程同步问题

需求：总共有50张火车票，有两个售卖火车票的窗口，一个是北京火车票售卖窗口，另一个是上海火车票售卖窗口。两个窗口同时售卖火车票，卖完为止。

6.6.2.1 非线程安全（不使用 `semaphore`）

/**
 * 非线程安全：不使用 semaphore
 * 初始化火车票数量、卖票窗口(非线程安全)、并开始卖票
 */
- (void)initTicketStatusNotSafeTask{
    NSLog(@"当前线程 : %@",[NSThread currentThread]);
    NSLog(@"initTicketStatusNotSafeTask : begin");
    
    self.ticketSurplusCount = 10;
    
    // queue1 代表北京火车票售卖窗口
    dispatch_queue_t queue1 = dispatch_queue_create("net.gcd.testQueue1", DISPATCH_QUEUE_SERIAL);
    // queue2 代表上海火车票售卖窗口
    dispatch_queue_t queue2 = dispatch_queue_create("net.gcd.testQueue2", DISPATCH_QUEUE_SERIAL);

    __weak typeof(self) ws = self;
    dispatch_async(queue1, ^{
        [ws saleTicketNotSafeTask];
    });
    
    dispatch_async(queue2, ^{
        [ws saleTicketNotSafeTask];
    });
}

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

日志输出:

2019-08-19 11:53:16.220078+0800 XKHttpNetworkHelper[20418:614512] 当前线程 : <NSThread: 0x600002caa940>{number = 1, name = main}
2019-08-19 11:53:16.220223+0800 XKHttpNetworkHelper[20418:614512] initTicketStatusNotSafeTask : begin
2019-08-19 11:53:16.220462+0800 XKHttpNetworkHelper[20418:614556] 剩余票数：8 窗口：<NSThread: 0x600002cf50c0>{number = 4, name = (null)}
2019-08-19 11:53:16.220498+0800 XKHttpNetworkHelper[20418:614561] 剩余票数：9 窗口：<NSThread: 0x600002cc3d40>{number = 3, name = (null)}
2019-08-19 11:53:16.423119+0800 XKHttpNetworkHelper[20418:614556] 剩余票数：6 窗口：<NSThread: 0x600002cf50c0>{number = 4, name = (null)}
2019-08-19 11:53:16.423124+0800 XKHttpNetworkHelper[20418:614561] 剩余票数：7 窗口：<NSThread: 0x600002cc3d40>{number = 3, name = (null)}
2019-08-19 11:53:16.627985+0800 XKHttpNetworkHelper[20418:614561] 剩余票数：4 窗口：<NSThread: 0x600002cc3d40>{number = 3, name = (null)}
2019-08-19 11:53:16.627986+0800 XKHttpNetworkHelper[20418:614556] 剩余票数：5 窗口：<NSThread: 0x600002cf50c0>{number = 4, name = (null)}
2019-08-19 11:53:16.828705+0800 XKHttpNetworkHelper[20418:614556] 剩余票数：3 窗口：<NSThread: 0x600002cf50c0>{number = 4, name = (null)}
2019-08-19 11:53:16.828705+0800 XKHttpNetworkHelper[20418:614561] 剩余票数：2 窗口：<NSThread: 0x600002cc3d40>{number = 3, name = (null)}
2019-08-19 11:53:17.030931+0800 XKHttpNetworkHelper[20418:614556] 剩余票数：1 窗口：<NSThread: 0x600002cf50c0>{number = 4, name = (null)}
2019-08-19 11:53:17.030943+0800 XKHttpNetworkHelper[20418:614561] 剩余票数：1 窗口：<NSThread: 0x600002cc3d40>{number = 3, name = (null)}
2019-08-19 11:53:17.232633+0800 XKHttpNetworkHelper[20418:614556] 剩余票数：0 窗口：<NSThread: 0x600002cf50c0>{number = 4, name = (null)}
2019-08-19 11:53:17.232645+0800 XKHttpNetworkHelper[20418:614561] 剩余票数：0 窗口：<NSThread: 0x600002cc3d40>{number = 3, name = (null)}
2019-08-19 11:53:17.434801+0800 XKHttpNetworkHelper[20418:614556] 所有火车票均已售完
2019-08-19 11:53:17.434811+0800 XKHttpNetworkHelper[20418:614561] 所有火车票均已售完

从执行任务的输出日志中可以看到:

在不考虑线程安全，不使用 semaphore 的情况下，得到票数是错乱的，这样显然不符合我们的需求，所以我们需要考虑线程安全问题。

6.6.2.2 线程安全（使用 `semaphore` 加锁）

/**
 * 线程安全：使用 semaphore 加锁
 * 初始化火车票数量、卖票窗口(线程安全)、并开始卖票
 */
- (void)initTicketStatusSafeTask{
    NSLog(@"当前线程 : %@",[NSThread currentThread]);
    NSLog(@"initTicketStatusNotSafeTask : begin");
    
    self.semaphoreLock = dispatch_semaphore_create(1);
    
    self.ticketSurplusCount = 10;
    
    // queue1 代表北京火车票售卖窗口
    dispatch_queue_t queue1 = dispatch_queue_create("net.gcd.testQueue1", DISPATCH_QUEUE_SERIAL);
    // queue2 代表上海火车票售卖窗口
    dispatch_queue_t queue2 = dispatch_queue_create("net.gcd.testQueue2", DISPATCH_QUEUE_SERIAL);

    __weak typeof(self) ws = self;
    dispatch_async(queue1, ^{
        [ws saleTicketSafeTask];
    });
    
    dispatch_async(queue2, ^{
        [ws saleTicketSafeTask];
    });
}

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

日志输出:

2019-08-19 12:02:25.846200+0800 XKHttpNetworkHelper[20593:640200] 当前线程 : <NSThread: 0x600003ed2900>{number = 1, name = main}
2019-08-19 12:02:25.846374+0800 XKHttpNetworkHelper[20593:640200] initTicketStatusNotSafeTask : begin
2019-08-19 12:02:25.846739+0800 XKHttpNetworkHelper[20593:640300] 剩余票数：9 窗口：<NSThread: 0x600003e8c700>{number = 3, name = (null)}
2019-08-19 12:02:26.051095+0800 XKHttpNetworkHelper[20593:640302] 剩余票数：8 窗口：<NSThread: 0x600003ede500>{number = 4, name = (null)}
2019-08-19 12:02:26.256409+0800 XKHttpNetworkHelper[20593:640300] 剩余票数：7 窗口：<NSThread: 0x600003e8c700>{number = 3, name = (null)}
2019-08-19 12:02:26.459732+0800 XKHttpNetworkHelper[20593:640302] 剩余票数：6 窗口：<NSThread: 0x600003ede500>{number = 4, name = (null)}
2019-08-19 12:02:26.664534+0800 XKHttpNetworkHelper[20593:640300] 剩余票数：5 窗口：<NSThread: 0x600003e8c700>{number = 3, name = (null)}
2019-08-19 12:02:26.869298+0800 XKHttpNetworkHelper[20593:640302] 剩余票数：4 窗口：<NSThread: 0x600003ede500>{number = 4, name = (null)}
2019-08-19 12:02:27.073980+0800 XKHttpNetworkHelper[20593:640300] 剩余票数：3 窗口：<NSThread: 0x600003e8c700>{number = 3, name = (null)}
2019-08-19 12:02:27.278409+0800 XKHttpNetworkHelper[20593:640302] 剩余票数：2 窗口：<NSThread: 0x600003ede500>{number = 4, name = (null)}
2019-08-19 12:02:27.480733+0800 XKHttpNetworkHelper[20593:640300] 剩余票数：1 窗口：<NSThread: 0x600003e8c700>{number = 3, name = (null)}
2019-08-19 12:02:27.683954+0800 XKHttpNetworkHelper[20593:640302] 剩余票数：0 窗口：<NSThread: 0x600003ede500>{number = 4, name = (null)}
2019-08-19 12:02:27.887163+0800 XKHttpNetworkHelper[20593:640300] 所有火车票均已售完
2019-08-19 12:02:27.887329+0800 XKHttpNetworkHelper[20593:640302] 所有火车票均已售完

从执行任务的输出日志中可以看到:

在考虑了线程安全的情况下，使用 dispatch_semaphore 机制之后，得到的票数是正确的，没有出现混乱的情况。

一了百-了

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
iOS 边学边记 GCD使用详解

一、GCD简介Grand Central Dispatch(GCD) 是 Apple 开发的一个多核编程的较新的解决方法。它主要用于优化应用程序以支持多核处理器以及其他对称多处理系统。是一个在线程池模式的基础上执行的并发任务为什么要用 GCD 呢？GCD 可用于多核的并行运算GCD 会自动利用更多的 CPU 内核（比如双核、四核）GCD 会自动管理线程的生命周期（创建线程、调度任务、销毁线程）程序员只需要告诉GCD想要执行什么任务，不需要编写任何线程管理代码二、GCD 任务和队列2..
复制链接

扫一扫