iOS-多线程：GCD

作者: 我是谁重要吗 | 来源:发表于2018-04-25 21:57 被阅读9次

GCD 简介
GCD 任务和队列
GCD 的使用步骤
GCD 的基本使用（6种不同组合区别）
GCD 线程间的通信
GCD 的其他方法

1. GCD 简介：

定义：
Grand Central Dispatch
•GCD 是苹果公司为多核的并发运算提出的解决方案（多核编程支持多核处理器）
•一个多核编程的较新的解决方法。
•它主要用于优化应用程序以支持多核处理器以及其他对称多处理系统。
•它是一个在线程池模式的基础上执行的并发任务。
优点：
•GCD会自动利用更多的CPU内核（比如双核、四核）
•GCD会自动管理线程的生命周期（创建线程、调度任务、销毁线程）
•程序员只需要告诉 GCD 需要执行什么任务, 不需要编写任何线程管理代码
•GCD会自动将队列中的任务取出，放到对应的线程中执行
•任务的取出遵循队列的FIFO原则：先进先出，后进后出

工作原理：

把任务放到对应队列中，根据可用的处理资源，安排这些任务在任何可用的处理器核心上执行。
一个任务可以是一个函数（function）或者是一个block对象

2. GCD 任务和队列

队列：

定义
指执行任务的等待队列，即用来存放任务的队列。队列是一种特殊的线性表，采用 FIFO（先进先出）的原则，即新任务总是被插入到队列的末尾，而读取任务的时候总是从队列的头部开始读取。每读取一个任务，则从队列中释放一个任务。
分为：
串行队列、并发队列
两者都符合 FIFO（先进先出）的原则。两者的主要区别是：执行顺序不同，以及开启线程数不同。
串行队列（Serial Dispatch Queue）：
每次只有一个任务被执行。让任务一个接着一个地执行。（只开启一个线程，一个任务执行完毕后，再执行下一个任务）
并发队列（Concurrent Dispatch Queue）：
可以让多个任务并发（同时）执行。（可以开启多个线程，并且同时执行任务）
注意：并发队列的并发功能只有在异步（dispatch_async）函数下才有效

GCD中队列： dispatch_queue_t queue

dispatch queue分类：

主队列：main dispatch queue(系统提供的串行队列)、
全局队列：global dispatch queue(系统提供的并发队列)、
自定义队列 dispatch queue (串行队列、并发队列)

主队列 main dispatch queue：

是全局性的serial queue（串行队列），和UI相关的放到queue里面，在主线程执行，先进先出，依次执行，是应用程序启动时，由系统预先创建的。通过宏dispatch_get_main_queue()获取；
和主线程相关联的队列，主队列是GCD自带的一种特殊的串行队列，放在主队列中的任务，都会放到主线程中执行。

dispatch_queue_t queue = dispatch_get_main_queue();

全局队列 global dispatch queue：

是并发队列，通过函数dispatch_get_global_queue(0,0)
（第一个0为优先级：DISPATCH_QUEUE_PRIORITY_DEFAULT等。第二个为保留字段备用）

dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

自定义队列 dispatch queue：

同时执行一个任务，其中的任务一般和UI无关，通过dispatch_queue_create(“SerialQueue”,DISPATCH_QUEUE_SERIAL) 创建
第一个参数：标识符，
第二个是类型：
串行 DISPATCH_QUEUE_SERIAL
并行 DISPATCH_QUEUE_CONCURRENT

//并发队列：
dispatch_queue_t queue = dispatch_queue_create("abc", DISPATCH_QUEUE_CONCURRENT);
//串行队列：
dispatch_queue_t queue = dispatch_queue_create("abc", DISPATCH_QUEUE_SERIAL);

任务：

执行的什么操作，就是在线程中执行的那段代码。在 GCD 中是放在 block 中的。
执行任务有两种方式：同步执行（dispatch_sync）和异步执行（dispatch_async）。
两者的主要区别是：是否等待队列的任务执行结束，以及是否具备开启新线程的能力，在新的线程中执行。

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

同步异步的区别：

同步函数不具备开启线程的能力，无论是什么队列都不会开启线程；异步函数具备开启线程的能力，开启几条线程由队列决定（串行队列只会开启一条新的线程，并发队列会开启多条线程）
（同步提交要等到提交的block完成之后才返回；异步提交是提交block后就返回）

异步执行（dispatch_async）虽然具有开启新线程的能力，但是并不一定开启新线程。

3. GCD 的使用步骤

1、创建一个队列（串行队列或并发队列）
2、将任务(block执行代码)以何种方式(同步执行或异步执行)提交到队列中

创建完后提交方法：

同步提交：
void dispatch_sync(dispatch_queue_t queue,dispatch_block_t block);

dispatch_sync(dispatch_queue_t queue, ^{
        // block 内容
    });

异步提交：
void dispatch_async(dispatch_queue_t queue,dispatch_block_t block);

dispatch_async(dispatch_queue_t queue, ^{
        // block 内容
    });

(第一个参数是提交到什么队列：main queue, global queue, 自定义queue)
(第二个参数是提交的任务:block代码块)

4. GCD 的基本使用（6种不同组合区别）

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

区别	并发队列	串行队列	主队列
同步(sync)	没有开启新线程，串行执行任务	没有开启新线程，串行执行任务	主线程调用：死锁卡住不执行其他线程调用：没有开启新线程，串行执行任务
异步(async)	有开启新线程，并发执行任务	有开启新线程(1条)，串行执行任务	没有开启新线程，串行执行任务

4.1 同步执行 + 并发队列

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

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

2018-04-25 17:30:34.773461+0800 Miller[2583:30535828] currentThread---<NSThread: 0x60000006df40>{number = 1, name = main}
2018-04-25 17:30:34.773632+0800 Miller[2583:30535828] syncConcurrent---begin
2018-04-25 17:30:36.775138+0800 Miller[2583:30535828] 1---<NSThread: 0x60000006df40>{number = 1, name = main}
2018-04-25 17:30:38.775614+0800 Miller[2583:30535828] 1---<NSThread: 0x60000006df40>{number = 1, name = main}
2018-04-25 17:30:40.776910+0800 Miller[2583:30535828] 2---<NSThread: 0x60000006df40>{number = 1, name = main}
2018-04-25 17:30:42.777255+0800 Miller[2583:30535828] 2---<NSThread: 0x60000006df40>{number = 1, name = main}
2018-04-25 17:30:44.782533+0800 Miller[2583:30535828] 3---<NSThread: 0x60000006df40>{number = 1, name = main}
2018-04-25 17:30:46.784044+0800 Miller[2583:30535828] 3---<NSThread: 0x60000006df40>{number = 1, name = main}
2018-04-25 17:30:46.784312+0800 Miller[2583:30535828] syncConcurrent---end

从同步执行 + 并发队列中可看到：

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

4.2 异步执行 + 并发队列

可以开启多个线程，任务交替（同时）执行。

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

2018-04-25 17:31:57.507461+0800 Miller[2602:30537280] currentThread---<NSThread: 0x604000072600>{number = 1, name = main}
2018-04-25 17:31:57.507646+0800 Miller[2602:30537280] asyncConcurrent---begin
2018-04-25 17:31:57.507835+0800 Miller[2602:30537280] asyncConcurrent---end
2018-04-25 17:31:59.511382+0800 Miller[2602:30537346] 2---<NSThread: 0x60400046ab80>{number = 4, name = (null)}
2018-04-25 17:31:59.511369+0800 Miller[2602:30537345] 3---<NSThread: 0x600000268c40>{number = 5, name = (null)}
2018-04-25 17:31:59.511377+0800 Miller[2602:30537344] 1---<NSThread: 0x600000263fc0>{number = 3, name = (null)}
2018-04-25 17:32:01.515298+0800 Miller[2602:30537344] 1---<NSThread: 0x600000263fc0>{number = 3, name = (null)}
2018-04-25 17:32:01.515298+0800 Miller[2602:30537346] 2---<NSThread: 0x60400046ab80>{number = 4, name = (null)}
2018-04-25 17:32:01.515341+0800 Miller[2602:30537345] 3---<NSThread: 0x600000268c40>{number = 5, name = (null)}

在异步执行 + 并发队列中可以看出：

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

4.3 同步执行 + 串行队列

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

/**
 * 同步执行 + 串行队列
 * 特点：不会开启新线程，在当前线程执行任务。任务是串行的，执行完一个任务，再执行下一个任务。
 */
- (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
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
            NSLog(@"1---%@",[NSThread currentThread]);      // 打印当前线程
        }
    });
    dispatch_sync(queue, ^{
        // 追加任务2
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
            NSLog(@"2---%@",[NSThread currentThread]);      // 打印当前线程
        }
    });
    dispatch_sync(queue, ^{
        // 追加任务3
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
            NSLog(@"3---%@",[NSThread currentThread]);      // 打印当前线程
        }
    });
    
    NSLog(@"syncSerial---end");
}

2018-04-25 17:32:59.197561+0800 Miller[2618:30538363] currentThread---<NSThread: 0x6000000720c0>{number = 1, name = main}
2018-04-25 17:32:59.197850+0800 Miller[2618:30538363] syncSerial---begin
2018-04-25 17:33:01.199286+0800 Miller[2618:30538363] 1---<NSThread: 0x6000000720c0>{number = 1, name = main}
2018-04-25 17:33:03.200554+0800 Miller[2618:30538363] 1---<NSThread: 0x6000000720c0>{number = 1, name = main}
2018-04-25 17:33:05.201809+0800 Miller[2618:30538363] 2---<NSThread: 0x6000000720c0>{number = 1, name = main}
2018-04-25 17:33:07.203213+0800 Miller[2618:30538363] 2---<NSThread: 0x6000000720c0>{number = 1, name = main}
2018-04-25 17:33:09.204608+0800 Miller[2618:30538363] 3---<NSThread: 0x6000000720c0>{number = 1, name = main}
2018-04-25 17:33:11.206041+0800 Miller[2618:30538363] 3---<NSThread: 0x6000000720c0>{number = 1, name = main}
2018-04-25 17:33:11.206354+0800 Miller[2618:30538363] syncSerial---end

在同步执行 + 串行队列可以看到：

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

4.4 异步执行 + 串行队列

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

/**
 * 异步执行 + 串行队列
 * 特点：会开启新线程，但是因为任务是串行的，执行完一个任务，再执行下一个任务。
 */
- (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
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
            NSLog(@"1---%@",[NSThread currentThread]);      // 打印当前线程
        }
    });
    dispatch_async(queue, ^{
        // 追加任务2
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
            NSLog(@"2---%@",[NSThread currentThread]);      // 打印当前线程
        }
    });
    dispatch_async(queue, ^{
        // 追加任务3
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
            NSLog(@"3---%@",[NSThread currentThread]);      // 打印当前线程
        }
    });
    
    NSLog(@"asyncSerial---end");
}

2018-04-25 17:34:50.727064+0800 Miller[2642:30540071] currentThread---<NSThread: 0x60400006e880>{number = 1, name = main}
2018-04-25 17:34:50.727232+0800 Miller[2642:30540071] asyncSerial---begin
2018-04-25 17:34:50.727368+0800 Miller[2642:30540071] asyncSerial---end
2018-04-25 17:34:52.727761+0800 Miller[2642:30540120] 1---<NSThread: 0x60000026fec0>{number = 3, name = (null)}
2018-04-25 17:34:54.728410+0800 Miller[2642:30540120] 1---<NSThread: 0x60000026fec0>{number = 3, name = (null)}
2018-04-25 17:34:56.733022+0800 Miller[2642:30540120] 2---<NSThread: 0x60000026fec0>{number = 3, name = (null)}
2018-04-25 17:34:58.739750+0800 Miller[2642:30540120] 2---<NSThread: 0x60000026fec0>{number = 3, name = (null)}
2018-04-25 17:35:00.742334+0800 Miller[2642:30540120] 3---<NSThread: 0x60000026fec0>{number = 3, name = (null)}
2018-04-25 17:35:02.746786+0800 Miller[2642:30540120] 3---<NSThread: 0x60000026fec0>{number = 3, name = (null)}

在异步执行 + 串行队列可以看到：

开启了一条新线程（异步执行具备开启新线程的能力，串行队列只开启一个线程）。
所有任务是在打印的syncConcurrent---begin和syncConcurrent---end之后才开始执行的（异步执行不会做任何等待，可以继续执行任务）。
任务是按顺序执行的（串行队列每次只有一个任务被执行，任务一个接一个按顺序执行）。
下边讲讲刚才我们提到过的特殊队列：主队列。

主队列：GCD自带的一种特殊的串行队列
所有放在主队列中的任务，都会放到主线程中执行
可使用dispatch_get_main_queue()获得主队列
我们再来看看主队列的两种组合方式。

4.5 同步执行 + 主队列

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

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

互相等待卡住不可行

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

2018-04-25 17:35:48.920726+0800 Miller[2656:30541188] currentThread---<NSThread: 0x604000261400>{number = 1, name = main}
2018-04-25 17:35:48.920906+0800 Miller[2656:30541188] syncMain---begin
(lldb)

在同步执行 + 主队列可以惊奇的发现：

在主线程中使用同步执行 + 主队列，追加到主线程的任务1、任务2、任务3都不再执行了，而且syncMain---end也没有打印，在XCode 9上还会报崩溃。这是为什么呢？
这是因为我们在主线程中执行syncMain方法，相当于把syncMain任务放到了主线程的队列中。而同步执行会等待当前队列中的任务执行完毕，才会接着执行。那么当我们把任务1追加到主队列中，任务1就在等待主线程处理完syncMain任务。而syncMain任务需要等待任务1执行完毕，才能接着执行。

那么，现在的情况就是syncMain任务和任务1都在等对方执行完毕。这样大家互相等待，所以就卡住了，所以我们的任务执行不了，而且syncMain---end也没有打印。

要是如果不在主线程中调用，而在其他线程中调用会如何呢？

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

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

// 使用 NSThread 的 detachNewThreadSelector 方法会创建线程，并自动启动线程执行
 selector 任务
[NSThread detachNewThreadSelector:@selector(syncMain) toTarget:self withObject:nil];

2018-04-25 17:37:00.080785+0800 Miller[2674:30542474] currentThread---<NSThread: 0x600000467a80>{number = 3, name = (null)}
2018-04-25 17:37:00.080955+0800 Miller[2674:30542474] syncMain---begin
2018-04-25 17:37:02.088226+0800 Miller[2674:30542391] 1---<NSThread: 0x600000078a00>{number = 1, name = main}
2018-04-25 17:37:04.089564+0800 Miller[2674:30542391] 1---<NSThread: 0x600000078a00>{number = 1, name = main}
2018-04-25 17:37:06.090751+0800 Miller[2674:30542391] 2---<NSThread: 0x600000078a00>{number = 1, name = main}
2018-04-25 17:37:08.092335+0800 Miller[2674:30542391] 2---<NSThread: 0x600000078a00>{number = 1, name = main}
2018-04-25 17:37:10.096493+0800 Miller[2674:30542391] 3---<NSThread: 0x600000078a00>{number = 1, name = main}
2018-04-25 17:37:12.098096+0800 Miller[2674:30542391] 3---<NSThread: 0x600000078a00>{number = 1, name = main}
2018-04-25 17:37:12.098408+0800 Miller[2674:30542474] syncMain---end

在其他线程中使用同步执行 + 主队列可看到：

所有任务都是在主线程（非当前线程）中执行的，没有开启新的线程（所有放在主队列中的任务，都会放到主线程中执行）。
所有任务都在打印的syncConcurrent---begin和syncConcurrent---end之间执行（同步任务需要等待队列的任务执行结束）。
任务是按顺序执行的（主队列是串行队列，每次只有一个任务被执行，任务一个接一个按顺序执行）。
为什么现在就不会卡住了呢？
因为syncMain 任务放到了其他线程里，而任务1、任务2、任务3都在追加到主队列中，这三个任务都会在主线程中执行。syncMain 任务在其他线程中执行到追加任务1到主队列中，因为主队列现在没有正在执行的任务，所以，会直接执行主队列的任务1，等任务1执行完毕，再接着执行任务2、任务3。所以这里不会卡住线程。

4.6 异步执行 + 主队列

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

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

2018-04-25 17:03:24.368195+0800 Miller[2476:30519935] currentThread---<NSThread: 0x60000007c840>{number = 1, name = main}
2018-04-25 17:03:24.368348+0800 Miller[2476:30519935] asyncMain---begin
2018-04-25 17:03:24.368468+0800 Miller[2476:30519935] asyncMain---end
2018-04-25 17:03:26.374601+0800 Miller[2476:30519935] 1---<NSThread: 0x60000007c840>{number = 1, name = main}
2018-04-25 17:03:28.375947+0800 Miller[2476:30519935] 1---<NSThread: 0x60000007c840>{number = 1, name = main}
2018-04-25 17:03:30.377242+0800 Miller[2476:30519935] 2---<NSThread: 0x60000007c840>{number = 1, name = main}
2018-04-25 17:03:32.378721+0800 Miller[2476:30519935] 2---<NSThread: 0x60000007c840>{number = 1, name = main}
2018-04-25 17:03:34.380346+0800 Miller[2476:30519935] 3---<NSThread: 0x60000007c840>{number = 1, name = main}
2018-04-25 17:03:36.381992+0800 Miller[2476:30519935] 3---<NSThread: 0x60000007c840>{number = 1, name = main}

在异步执行 + 主队列可以看到：

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

5. GCD 线程间的通信

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

/**
 * 线程间通信
 */
- (void)communication {
    // 获取全局并发队列
    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 (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
            NSLog(@"1---%@",[NSThread currentThread]);      // 打印当前线程
        }
        
        // 回到主线程
        dispatch_async(mainQueue, ^{
            // 追加在主线程中执行的任务
            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
            NSLog(@"2---%@",[NSThread currentThread]);      // 打印当前线程
        });
    });
}

2018-04-25 20:08:13.702611+0800 Miller[3120:30631965] 1---<NSThread: 0x604000279e00>{number = 3, name = (null)}
2018-04-25 20:08:15.707063+0800 Miller[3120:30631965] 1---<NSThread: 0x604000279e00>{number = 3, name = (null)}
2018-04-25 20:08:17.708399+0800 Miller[3120:30631854] 2---<NSThread: 0x60400007f880>{number = 1, name = main}

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

6. GCD 的其他方法

栅栏方法：dispatch_barrier_async、
延时执行方法：dispatch_after、
一次性代码（只执行一次）：dispatch_once、
快速迭代(循环遍历)：dispatch_apply、
队列组：dispatch_group、
信号量：dispatch_semaphore
dispatch_suspend和dispatch_resume

6.1 GCD 栅栏方法：dispatch_barrier_async

栅栏函数不能和全局并发队列使用
只能dispatch_queue_create的并发队列中使用

栅栏的作用执行完前面的，再执行本身，然后执行后面的。类似于NSOperation的依赖
使用栅栏函数时，使用全局并发队列是无效的，只有使用create创建的并发队列才有效
我们有时需要异步执行两组操作，而且第一组操作执行完之后，才能开始执行第二组操作。这样我们就需要一个相当于栅栏一样的一个方法将两组异步执行的操作组给分割起来，当然这里的操作组里可以包含一个或多个任务。这就需要用到dispatch_barrier_async方法在两个操作组间形成栅栏。
dispatch_barrier_async函数会等待前边追加到并发队列中的任务全部执行完毕之后，再将指定的任务追加到该异步队列中。然后在dispatch_barrier_async函数追加的任务执行完毕之后，异步队列才恢复为一般动作，接着追加任务到该异步队列并开始执行。具体如下图所示：

/**
 * 栅栏方法 dispatch_barrier_async
 */
- (void)barrier {
    dispatch_queue_t queue = dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_CONCURRENT);
    
    dispatch_async(queue, ^{
        // 追加任务1
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
            NSLog(@"1---%@",[NSThread currentThread]);      // 打印当前线程
        }
    });
    dispatch_async(queue, ^{
        // 追加任务2
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
            NSLog(@"2---%@",[NSThread currentThread]);      // 打印当前线程
        }
    });
    
    dispatch_barrier_async(queue, ^{
        // 追加任务 barrier
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
            NSLog(@"barrier---%@",[NSThread currentThread]);// 打印当前线程
        }
    });
    
    dispatch_async(queue, ^{
        // 追加任务3
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
            NSLog(@"3---%@",[NSThread currentThread]);      // 打印当前线程
        }
    });
    dispatch_async(queue, ^{
        // 追加任务4
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
            NSLog(@"4---%@",[NSThread currentThread]);      // 打印当前线程
        }
    });
}

2018-04-25 20:11:19.137854+0800 Miller[3145:30634479] 2---<NSThread: 0x6040004601c0>{number = 4, name = (null)}
2018-04-25 20:11:19.137865+0800 Miller[3145:30634481] 1---<NSThread: 0x600000468a00>{number = 3, name = (null)}
2018-04-25 20:11:21.139148+0800 Miller[3145:30634481] 1---<NSThread: 0x600000468a00>{number = 3, name = (null)}
2018-04-25 20:11:21.139400+0800 Miller[3145:30634479] 2---<NSThread: 0x6040004601c0>{number = 4, name = (null)}
2018-04-25 20:11:23.141727+0800 Miller[3145:30634479] barrier---<NSThread: 0x6040004601c0>{number = 4, name = (null)}
2018-04-25 20:11:25.144842+0800 Miller[3145:30634479] barrier---<NSThread: 0x6040004601c0>{number = 4, name = (null)}
2018-04-25 20:11:27.145914+0800 Miller[3145:30634479] 3---<NSThread: 0x6040004601c0>{number = 4, name = (null)}
2018-04-25 20:11:27.145914+0800 Miller[3145:30634481] 4---<NSThread: 0x600000468a00>{number = 3, name = (null)}
2018-04-25 20:11:29.150341+0800 Miller[3145:30634479] 3---<NSThread: 0x6040004601c0>{number = 4, name = (null)}
2018-04-25 20:11:29.150347+0800 Miller[3145:30634481] 4---<NSThread: 0x600000468a00>{number = 3, name = (null)}

在dispatch_barrier_async执行结果中可以看出：

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

6.2 GCD 延时执行方法：dispatch_after

dispatch_after延时添加到队列

我们经常会遇到这样的需求：在指定时间（例如3秒）之后执行某个任务。可以用 GCD 的dispatch_after函数来实现。
需要注意的是：dispatch_after函数并不是在指定时间之后才开始执行处理，而是在指定时间之后将任务追加到指定队列(主队列)中。严格来说，这个时间并不是绝对准确的，但想要大致延迟执行任务，dispatch_after函数是很有效的。

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

2018-04-25 20:13:06.596406+0800 Miller[3166:30635941] currentThread---<NSThread: 0x600000079fc0>{number = 1, name = main}
2018-04-25 20:13:06.596575+0800 Miller[3166:30635941] asyncMain---begin
2018-04-25 20:13:08.596956+0800 Miller[3166:30635941] after---<NSThread: 0x600000079fc0>{number = 1, name = main}

可以看出：在打印 asyncMain---begin 之后大约 2.0 秒的时间，打印了 after---<NSThread: 0x60000006ee00>{number = 1, name = main}

NSObject的延时方法：[self performSelector:@selector(run) withObject:nil afterDelay:2.0];

6.3 GCD 一次性代码（只执行一次）：dispatch_once

我们在创建单例、或者有整个程序运行过程中只执行一次的代码时，我们就用到了 GCD 的 dispatch_once 函数。使用
dispatch_once 函数能保证某段代码在程序运行过程中只被执行1次:比如单例，并且即使在多线程的环境下，dispatch_once也可以保证线程安全。

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

6.4 GCD 快速迭代方法：dispatch_apply

dispatch_apply在给定的队列上多次执行某一任务，在主线程直接调用会阻塞主线程去执行block中的任务。

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

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

2018-04-25 20:15:22.683791+0800 Miller[3188:30637986] apply---begin
2018-04-25 20:15:22.684063+0800 Miller[3188:30637986] 0---<NSThread: 0x60400007d180>{number = 1, name = main}
2018-04-25 20:15:22.684148+0800 Miller[3188:30638062] 1---<NSThread: 0x604000663a40>{number = 3, name = (null)}
2018-04-25 20:15:22.684191+0800 Miller[3188:30638061] 2---<NSThread: 0x604000478540>{number = 4, name = (null)}
2018-04-25 20:15:22.684227+0800 Miller[3188:30638060] 3---<NSThread: 0x604000479700>{number = 5, name = (null)}
2018-04-25 20:15:22.684407+0800 Miller[3188:30637986] 4---<NSThread: 0x60400007d180>{number = 1, name = main}
2018-04-25 20:15:22.684411+0800 Miller[3188:30638062] 5---<NSThread: 0x604000663a40>{number = 3, name = (null)}
2018-04-25 20:15:22.684867+0800 Miller[3188:30637986] apply---end

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

6.5 GCD 队列组：dispatch_group

dispatch_group_t groupQueue = dispatch_group_create();
使用函数dispatch_group_create创建dispatch group,
然后使用函数dispatch_group_async来将要执行的block任务提交到一个dispatch queue。同时将他们添加到一个组，等要执行的block任务全部执行完成之后，使用dispatch_group_notify函数接收完成时的消息。(下载两个图片后合并，可提交多个dispatch_group_async) （可以监听任务）

有时候我们会有这样的需求：分别异步执行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)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");
    });
}

2018-04-25 20:17:19.371428+0800 Miller[3208:30639608] currentThread---<NSThread: 0x600000075100>{number = 1, name = main}
2018-04-25 20:17:19.371613+0800 Miller[3208:30639608] group---begin
2018-04-25 20:17:21.374834+0800 Miller[3208:30639674] 2---<NSThread: 0x60400026c180>{number = 4, name = (null)}
2018-04-25 20:17:21.374837+0800 Miller[3208:30639673] 1---<NSThread: 0x60000027ae00>{number = 3, name = (null)}
2018-04-25 20:17:23.378845+0800 Miller[3208:30639674] 2---<NSThread: 0x60400026c180>{number = 4, name = (null)}
2018-04-25 20:17:23.378845+0800 Miller[3208:30639673] 1---<NSThread: 0x60000027ae00>{number = 3, name = (null)}
2018-04-25 20:17:25.379242+0800 Miller[3208:30639608] 3---<NSThread: 0x600000075100>{number = 1, name = main}
2018-04-25 20:17:27.380537+0800 Miller[3208:30639608] 3---<NSThread: 0x600000075100>{number = 1, name = main}
2018-04-25 20:17:27.380823+0800 Miller[3208:30639608] group---end

从dispatch_group_notify相关代码运行输出结果可以看出：
当所有任务都执行完成之后，才执行dispatch_group_notify block 中的任务。

6.5.2 dispatch_group_wait

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

/**
 * 队列组 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");
}

2018-04-25 20:18:38.526199+0800 Miller[3226:30640878] currentThread---<NSThread: 0x60400007f700>{number = 1, name = main}
2018-04-25 20:18:38.526367+0800 Miller[3226:30640878] group---begin
2018-04-25 20:18:40.527481+0800 Miller[3226:30640943] 2---<NSThread: 0x604000278b00>{number = 3, name = (null)}
2018-04-25 20:18:40.527486+0800 Miller[3226:30640945] 1---<NSThread: 0x60000046c300>{number = 4, name = (null)}
2018-04-25 20:18:42.531773+0800 Miller[3226:30640945] 1---<NSThread: 0x60000046c300>{number = 4, name = (null)}
2018-04-25 20:18:42.531773+0800 Miller[3226:30640943] 2---<NSThread: 0x604000278b00>{number = 3, name = (null)}
2018-04-25 20:18:42.531984+0800 Miller[3226:30640878] group---end

从dispatch_group_wait相关代码运行输出结果可以看出：
当所有任务执行完成之后，才执行 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)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");
    });
    
//    // 等待上面的任务全部完成后，会往下继续执行（会阻塞当前线程）
//    dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
//
//    NSLog(@"group---end");
}

2018-04-25 20:19:57.495296+0800 Miller[3246:30642229] currentThread---<NSThread: 0x600000073200>{number = 1, name = main}
2018-04-25 20:19:57.495457+0800 Miller[3246:30642229] group---begin
2018-04-25 20:19:59.497294+0800 Miller[3246:30642294] 1---<NSThread: 0x604000274d40>{number = 4, name = (null)}
2018-04-25 20:19:59.497299+0800 Miller[3246:30642291] 2---<NSThread: 0x60400026b780>{number = 3, name = (null)}
2018-04-25 20:20:01.499642+0800 Miller[3246:30642294] 1---<NSThread: 0x604000274d40>{number = 4, name = (null)}
2018-04-25 20:20:01.499642+0800 Miller[3246:30642291] 2---<NSThread: 0x60400026b780>{number = 3, name = (null)}
2018-04-25 20:20:03.500595+0800 Miller[3246:30642229] 3---<NSThread: 0x600000073200>{number = 1, name = main}
2018-04-25 20:20:05.500964+0800 Miller[3246:30642229] 3---<NSThread: 0x600000073200>{number = 1, name = main}
2018-04-25 20:20:05.501436+0800 Miller[3246:30642229] group---end

从dispatch_group_enter、dispatch_group_leave相关代码运行结果中可以看出：当所有任务执行完成之后，才执行 dispatch_group_notify 中的任务。这里的dispatch_group_enter、dispatch_group_leave组合，其实等同于dispatch_group_async。

6.6 GCD 信号量：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_create(1)：传入值必须 >=0, 若传入为 0 则阻塞线程并等待timeout,时间到后会执行其后的语句
dispatch_semaphore_wait(signal, overTime)：可以理解为 lock,会使得 signal 值 -1
dispatch_semaphore_signal(signal)：可以理解为 unlock,会使得 signal 值 +1

（凭钥匙进房间，进入房间钥匙-1，出来+1，信号量多少就是几个钥匙）

注意：信号量的使用前提是：想清楚你需要处理哪个线程等待（阻塞），又要哪个线程继续执行，然后使用信号量。
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 实现线程同步，将异步执行任务转换为同步执行任务。

/**
 * 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);
}

2018-04-25 21:11:26.095376+0800 Miller[3386:30669852] currentThread---<NSThread: 0x600000071b80>{number = 1, name = main}
2018-04-25 21:11:26.095548+0800 Miller[3386:30669852] semaphore---begin
2018-04-25 21:11:28.099069+0800 Miller[3386:30669915] 1---<NSThread: 0x600000273180>{number = 3, name = (null)}
2018-04-25 21:11:28.099245+0800 Miller[3386:30669852] semaphore---end,number = 100

从 Dispatch Semaphore 实现线程同步的代码可以看到：

semaphore---end 是在执行完 number = 100; 之后才打印的。而且输出结果 number 为 100。
这是因为异步执行不会做任何等待，可以继续执行任务。异步执行将任务1追加到队列之后，不做等待，接着执行dispatch_semaphore_wait方法。此时 semaphore == 0，当前线程进入等待状态。然后，异步任务1开始执行。任务1执行到dispatch_semaphore_signal之后，总信号量，此时 semaphore == 1，dispatch_semaphore_wait方法使总信号量减1，正在被阻塞的线程（主线程）恢复继续执行。最后打印semaphore---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)initTicketStatusNotSave {
    NSLog(@"currentThread---%@",[NSThread currentThread]);  // 打印当前线程
    NSLog(@"semaphore---begin");
    
    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 saleTicketNotSafe];
    });
    
    dispatch_async(queue2, ^{
        [weakSelf saleTicketNotSafe];
    });
}

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

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

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

考虑线程安全的代码：

/**
 * 线程安全：使用 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);
    }
}

可以看出，在考虑了线程安全的情况下，使用 dispatch_semaphore
机制之后，得到的票数是正确的，没有出现混乱的情况。我们也就解决了多个线程同步的问题。

iOS GCD之dispatch_semaphore（信号量）

6.7 dispatch_suspend和dispatch_resume

dispatch_suspend(dispatchQueue);
dispatch_resume(dispatchQueue);

这些函数不会影响到队列中已经执行的任务，队列暂停后，已经添加到队列中但是还没有执行的任务不会执行，直到队列被恢复。

官网：
https://developer.apple.com/library/ios/documentation/Performance/Reference/GCD_libdispatch_Ref/index.html
参考：
https://www.jianshu.com/p/2d57c72016c6
https://www.jianshu.com/p/905796f91f21 （推荐）
http://blog.csdn.net/crycheng/article/details/22214617
http://www.makaidong.com/博客园热/32954.shtml
http://www.cnblogs.com/wendingding/p/3806821.html