iOS多线程之 GCD

蔚落 2022-03-09 17:36 280阅读 0赞

## GCD的优势 ##

GCD是苹果公司为多核的并行运算提出的解决方案  
GCD会自动利用更多的CPU内核（比如双核、四核）  
GCD会自动管理线程的生命周期（创建线程、调度任务、销毁线程）  
程序员只需要告诉GCD想要执行什么任务，不需要编写任何线程管理代码（但是更优的做法是我们自己管理线程，这个后面会说到）

GCD的两个核心

*  任务：执行什么操作
 *  队列：用来存放任务

GCD使用的两个步骤

*  创建任务：确定要做的事情
 *  将任务添加到队列中
    
     *  GCD会自动将队列中的任务取出，放到对应的线程中执行
     *  任务的取出遵循队列的*FIFO*（First In First Out）原则：  
        先进先出，后进后出

--------------------

## 执行任务的方式 ##

GCD中有2个用来执行任务的函数

*  **同步**的方式执行任务

//queue：队列
    //block：任务
    dispatch_sync(dispatch_queue_t queue, dispatch_block_t block);

*  **异步**的方式执行任务

dispatch_async(dispatch_queue_t queue, dispatch_block_t block);

--------------------

## 队列的类型 ##

GCD的队列可以分为2大类型

*  **并发队列**（*Concurrent Dispatch Queue*）
    
     *  可以让多个任务并发（同时）执行（自动开启多个线程同时执行任务）
     *  并发功能只有在异步（dispatch\_async）函数下才有效
 *  **串行队列**（*Serial Dispatch Queue*）
    
     *  让任务一个接着一个地执行（一个任务执行完毕后，再执行下一个任务）

--------------------

## 小结 ##

同步和异步决定了要不要开启新的线程

*  **同步**：在当前线程中执行任务，不具备开启新线程的能力
 *  **异步**：在新的线程中执行任务，具备开启新线程的能力

并发和串行决定了任务的执行方式

*  **并发**：多个任务并发（同时）执行
 *  **串行**：一个任务执行完毕后，再执行下一个任务

--------------------

## 简单用法 ##

串行队列，同步执行

*  不会新建线程，按顺序执行任务(毫无用处) 补充:*在GCDAsyncSocket 有这种用法 用于切换当前任务的执行queue*
    
    GCDAsyncSocket

#define DISPATCH_QUEUE_SERIAL NULL
    //串行队列
    //dispatch_queue_t q = dispatch_queue_create("test", NULL);
    dispatch_queue_t q = dispatch_queue_create("test", DISPATCH_QUEUE_SERIAL);
    for (int i = 0; i < 10; i++) 
    {
        //同步执行
        dispatch_sync(q, ^{
           NSLog(@"%@ -- %d",[NSThread currentThread],i);
        });
    }

串行队列，异步执行

*  会新建线程，按顺序执行任务(非常有用)

//只有一个线程，因为是串行队列，只有一个线程就可以按顺序执行队列中的所有任务
    dispatch_queue_t q = dispatch_queue_create("test", DISPATCH_QUEUE_SERIAL);
        for (int i = 0; i < 10; i++) 
        {
            //异步执行
            dispatch_async(q, ^{
                NSLog(@"%@ -- %d",[NSThread currentThread],i);
            });
        }

并行队列，异步执行

*  会新建多个线程，但是无法确定任务的执行顺序(有用，但是很容易出错)

dispatch_queue_t q = dispatch_queue_create("test", DISPATCH_QUEUE_CONCURRENT);
        for (int i = 0; i < 10; i++) 
        {
            //异步执行
            dispatch_async(q, ^{
                NSLog(@"%@ -- %d",[NSThread currentThread],i);
            });
        }

并行队列，同步执行

*  不会新建线程，按顺序执行任务(几乎没用)

dispatch_queue_t q = dispatch_queue_create("test", DISPATCH_QUEUE_CONCURRENT);
        for (int i = 0; i < 10; i++)
        {
            //异步执行
            dispatch_sync(q, ^{
                NSLog(@"%@ -- %d",[NSThread currentThread],i);
            });
        }

--------------------

## 一些系统提供的队列 ##

全局队列

*  全局队列本质就是**并发队列**

dispatch_get_global_queue(0,0);

*  全局队列和并发队列的区别
 *  并发队列有名称，可以跟踪错误，全局队列没有
 *  在ARC中不需要考虑释放内存， dispatch\_release(q);不允许调用。在MRC中需要手动释放内存，并发队列是create创建出来的 在MRC中见到create就要release，全局队列不需要release（只有一个）
 *  一般我们使用全局队列，但是建议同一类事情创建一个固定的队列进行管理，比如编写SDK我们不能使得我们的SDK导入的时候影响到别人队列里面的操作，导致别人莫名其妙导入你的SDK之后出现了卡顿，因此建议编写网络框架、处理绘图、编写其他轮子代码的时候创建一个自己专属的队列。

主队列

*  主队列，异步任务
    
     *  不开线程，同步执行
     *  主队列特点：如果主线程正在执行代码暂时不调度任务，等主线程执行结束后在执行任务
     *  主队列又叫 全局串行队列
 *  主队列，同步执行
 *  程序执行不出来（死锁）
 *  死锁的原因，当程序执行到下面这段代码的时候  
    主队列：如果主线程正在执行代码，就不调度任务  
    同步执行：如果第一个任务没有执行，就继续等待第一个任务执行完成，再执行下一个任务此时互相等待，程序无法往下执行（死锁）

//主队列的特点:主队列只有当主线程空闲下来的时候才能够执行主队列里面的任务
        dispatch_sync(dispatch_get_main_queue(), ^{
            NSLog(@"哈哈");
        });

--------------------

# GCD 进阶 #

## 一次执行 `dispatch_once` ##

该函数的作用是保证block在程序的生命周期范围内只执行一次。最常用最常用的场景就是创建单例了

*  单例模式

+ (instancetype)sharedManager {
        static id instance;
        
        static dispatch_once_t onceToken;
        dispatch_once(&onceToken, ^{
            instance = [[self alloc] init];
        });
        
        return instance;
    }

--------------------

## 延迟执行 `Dispatch_after` ##

*  `dispatch_after`是来延迟执行的GCD方法，因为在主线程中我们不能用`sleep`来延迟方法的调用，所以用`dispatch_after`是最合适的
 *  `dispatch_after`能让我们添加进队列的任务延时执行，该函数并不是在指定时间后执行处理，而只是在指定时间追加处理到`dispatch_queue`

dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(<#delayInSeconds#> * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
            <#code to be executed after a specified delay#>
        });

--------------------

## 多次执行 `dispatch_apply` ##

把一项任务提交到队列中多次执行，具体是并行执行还是串行执行由队列本身决定.注意，dispatch\_apply不会立刻返回，在执行完毕后才会返回，是同步的调用。

/*
        iterations  执行的次数  
        queue       提交到的队列  
        block       执行的任务
     */
    dispatch_apply(size_t iterations,
                   dispatch_queue_t queue,
                   ^{
            <#code to be executed#>
        });

--------------------

## 阻塞 `dispatch_barrier` ##

`dispatch_barrier_async`用于等待前面的任务执行完毕后自己才执行，而它后面的任务需等待它完成之后才执行。一个典型的例子就是数据的读写，通常为了防止文件读写导致冲突，我们会创建一个串行的队列，所有的文件操作都是通过这个队列来执行，比如FMDB，这样就可以避免读写冲突。

- (void)dispatch_barrier_async
    {
        
        //创建一个并发队列
        dispatch_queue_t global_queue = dispatch_get_global_queue(0, 0);
        
        //异步把任务 放入 并发队列
        dispatch_async(global_queue, ^{
            NSLog(@"A开始 %@",[NSThread currentThread]);
            //模拟请求耗时
            sleep(2);
            NSLog(@"A完成 %@",[NSThread currentThread]);
        });
        
        dispatch_async(global_queue, ^{
            NSLog(@"B开始 %@",[NSThread currentThread]);
            sleep(1);
            NSLog(@"B完成 %@",[NSThread currentThread]);
        });
        
        dispatch_barrier_async(global_queue, ^{
            NSLog(@"dispatch_barrier_async");
        });
        
        dispatch_async(global_queue, ^{
            NSLog(@"C开始 %@",[NSThread currentThread]);
            sleep(3);
            NSLog(@"C完成 %@",[NSThread currentThread]);
        });
    
    }
    
    我们将写数据的操作放在dispatch_barrier_async中，这样能确保在写数据的时候会等待前面的读操作完成，而后续的读操作也会等到写操作完成后才能继续执行，提高文件读写的执行效率。

--------------------

## 调度组 `dispatch_group` ##

当我们想在gcd queue中所有的任务执行完毕之后做些特定事情的时候，也就是队列的同步问题，如果队列是串行的话，那将该操作最后添加到队列中即可，但如果队列是并行队列的话，这时候就可以利用`dispatch_group`来实现了，`dispatch_group`能很方便的解决同步的问题。`dispatch_group_create`可以创建一个group对象，然后可以添加block到该组里面

*  **dispatch\_group\_wait**  
    `dispatch_group_wait`会同步地等待group中所有的block执行完毕后才继续执行,类似于`dispatch_barrier`
 *  **dispatch\_group\_notify**  
    功能与`dispatch_group_wait`类似，不过该过程是异步的，不会阻塞该线程，`dispatch_group_notify`有三个参数

void dispatch_group_notify(dispatch_group_t group, //要观察的group
                             dispatch_queue_t queue,   //block执行的队列
                             dispatch_block_t block);   //当group中所有任务执行完毕之后要执行的block

*  **dispatch\_group\_enter && dispatch\_group\_leave**  
    假如我们不想使用`dispatch_group_async`异步的将任务丢到group中去执行，这时候就需要用到`dispatch_group_enter`跟`dispatch_group_leave`方法，这两个方法要配对出现，以下这两种方法是等价的：

dispatch_group_async(group, queue, ^{ 
    });

等价于

dispatch_group_enter(group);
    dispatch_async(queue, ^{
    　　dispatch_group_leave(group);
    });

(具体用法在下面实际应用)

--------------------

## 挂起队列 `dispatch_suspend`/ 恢复队列`dispatch_resume` ##

`dispatch_suspend`，`dispatch_resume`提供了“挂起、恢复”队列的功能简单来说，就是可以暂停、恢复队列上的任务。  
但是这里的“挂起”，只能挂起队列后面正在排队的任务，并不能让当前正在执行的任务停止

- (void)dispatch_suspend_resume
    {
        dispatch_queue_t queue = dispatch_queue_create("cn.jimmypeng", DISPATCH_QUEUE_SERIAL);
        //提交第一个block，延时5秒打印。
        dispatch_async(queue, ^{
            sleep(5);
            NSLog(@"After 5 seconds...");
        });
        //提交第二个block，也是延时5秒打印
        dispatch_async(queue, ^{
            sleep(5);
            NSLog(@"After 5 seconds again...");
        });
        //延时一秒
        NSLog(@"sleep 1 second...");
        sleep(1);
        //挂起队列
        NSLog(@"suspend...");
        dispatch_suspend(queue);
        //延时10秒
        NSLog(@"sleep 10 second...");
        sleep(10);
        //恢复队列
        NSLog(@"resume...");
        dispatch_resume(queue);
    }
    
    Log:
    16:24:27.565 GCD[10824:343675] sleep 1 second...
    16:24:28.566 GCD[10824:343675] suspend...
    16:24:28.567 GCD[10824:343675] sleep 10 second...
    16:24:32.569 GCD[10824:343750] After 5 seconds...
    16:24:38.568 GCD[10824:343675] resume...
    16:24:43.571 GCD[10824:343750] After 5 seconds again...
    
    在dispatch_suspend挂起队列后，第一个block还是在运行，并且正常输出。

--------------------

## 信号量 `dispatch_semaphore` ##

> 信号量(Semaphore)，有时被称为信号灯，是在多线程环境下使用的一种设施，是可以用来保证两个或多个关键代码段不被并发调用。在进入一个关键代码段之前，线程必须获取一个信号量；一旦该关键代码段完成了，那么该线程必须释放信号量。其它想进入该关键代码段的线程必须等待直到第一个线程释放信号量。为了完成这个过程，需要创建一个信号量VI，然后将Acquire Semaphore VI以及Release Semaphore VI分别放置在每个关键代码段的首末端。确认这些信号量VI引用的是初始创建的信号量。

但是这段文字可能过于抽象了，一般我们用停车的例子来阐释信号量控制线程的过程。

以一个停车场的运作为例。简单起见，假设停车场只有三个车位，一开始三个车位都是空的。这时如果同时来了五辆车，看门人允许其中三辆直接进入，然后放下车拦，剩下的车则必须在入口等待，此后来的车也都不得不在入口处等待。这时，有一辆车离开停车场，看门人得知后，打开车拦，放入外面的一辆进去，如果又离开两辆，则又可以放入两辆，如此往复。  
在这个停车场系统中，车位是公共资源，每辆车好比一个线程，看门人起的就是信号量的作用。

在GCD中有三个函数是semaphore的操作，  
分别是：

*  `dispatch_semaphore_create`创建一个semaphore　（创建车位，可以传入参数创建多少个车位）
 *  `dispatch_semaphore_signal`发送一个信号　 （告诉看门人有一辆车走了，空出来一个车位）
 *  `dispatch_semaphore_wait`等待信号 （看门人看到车来了，如果有空车位 让车进去，没有空车位，让车按顺序等待空车位，可以设置等待时间，设置之后过了等待时间，车直接开走，不再进入车库）

(具体用法在下面实际应用)

--------------------

## GCD 进阶实际应用场景 ##

### 异步下载图片 （异步请求，主线程刷新） ###

*  单个任务

- (void)downLoadImage
    {
        //下载图片耗费时间所以在子线程上面执行
        dispatch_async(dispatch_get_global_queue(0, 0), ^{
            NSLog(@"%@",[NSThread currentThread]);
            NSURL *url = [NSURL URLWithString:@"http://a.hiphotos.baidu.com/image/pic/item/b21c8701a18b87d6ff2ca7bc030828381f30fd23.jpg"];
            NSData *data = [NSData dataWithContentsOfURL:url];
            UIImage *img = [UIImage imageWithData:data];
            
         //刷新UI 在主线程刷新UI
            dispatch_async(dispatch_get_main_queue(), ^{
                 NSLog(@"main_queue %@",[NSThread currentThread]);
              self.MyImageView.image = img;
            });
            
        });
    }

*  下载三首歌曲,不要求下载顺序,但是三首歌曲全部下载完成之后,提示用户需要在主线程 （调度组）

- (void)dispatch_group_demo1
    {
        //创建一个调度组
        dispatch_group_t group = dispatch_group_create();
        
        //进入调度组
        dispatch_group_enter(group);
        dispatch_async(dispatch_get_global_queue(0, 0), ^{
            //模拟请求耗时
            sleep(2);
            NSLog(@"A");
            //事件完成 离开调度组
            dispatch_group_leave(group);
        });
        
        dispatch_group_enter(group);
        dispatch_async(dispatch_get_global_queue(0, 0), ^{
            sleep(1);
            NSLog(@"B");
            dispatch_group_leave(group);
        });
        
        dispatch_group_enter(group);
        dispatch_async(dispatch_get_global_queue(0, 0), ^{
            sleep(3);
            NSLog(@"C");
            dispatch_group_leave(group);
        });
        
        //所有任务从调度组里面拿出来 调用通知
        dispatch_group_notify(group, dispatch_get_main_queue(), ^{
            NSLog(@"完成");
        });
    }

- (void)dispatch_group_demo2
    {
    
        //调度组
        dispatch_group_t group = dispatch_group_create();
        
        /*
         参数1:调度组
         参数2:队列
         参数3:任务
         */
        dispatch_group_async(group, dispatch_get_global_queue(0, 0), ^{
            sleep(1);
            NSLog(@"下载第1首歌曲");
        });
        dispatch_group_async(group, dispatch_get_global_queue(0, 0), ^{
            sleep(1);
            NSLog(@"下载第2首歌曲");
        });
        dispatch_group_async(group, dispatch_get_global_queue(0, 0), ^{
            sleep(1);
            NSLog(@"下载第3首歌曲");
        });
        //通知
        dispatch_group_notify(group, dispatch_get_main_queue(), ^{
            NSLog(@"歌曲下载完成");
        });
    
    }

### 线程依赖 (异步串行/信号量) ###

*  通过串行队列进行线程依赖

- (void)dispatch_serial_queue
    {
           NSLog(@"开始");
        
        //创建一个串行队列
        dispatch_queue_t serial_queue = dispatch_queue_create("cn.jimmypeng", DISPATCH_QUEUE_SERIAL);
        
        //异步把任务 放入 串行队列
        dispatch_async(serial_queue, ^{
            NSLog(@"A开始 %@",[NSThread currentThread]);
            //模拟请求耗时
            sleep(2);
            NSLog(@"A完成 %@",[NSThread currentThread]);
        });
        
        dispatch_async(serial_queue, ^{
            NSLog(@"B开始 %@",[NSThread currentThread]);
            sleep(1);
            NSLog(@"B完成 %@",[NSThread currentThread]);
        });
        
        dispatch_async(serial_queue, ^{
            NSLog(@"C开始 %@",[NSThread currentThread]);
            sleep(3);
            NSLog(@"C完成 %@",[NSThread currentThread]);
        });
        
        NSLog(@"完成");
    }
    
    Log:
    16:09:06.520 GCD[10457:323508] 开始
    16:09:06.520 GCD[10457:323508] 完成
    16:09:06.520 GCD[10457:323550] A开始 <NSThread: 0x600000073880>{number = 3, name = (null)}
    16:09:08.524 GCD[10457:323550] A完成 <NSThread: 0x600000073880>{number = 3, name = (null)}
    16:09:08.524 GCD[10457:323550] B开始 <NSThread: 0x600000073880>{number = 3, name = (null)}
    16:09:09.525 GCD[10457:323550] B完成 <NSThread: 0x600000073880>{number = 3, name = (null)}
    16:09:09.525 GCD[10457:323550] C开始 <NSThread: 0x600000073880>{number = 3, name = (null)}
    16:09:12.529 GCD[10457:323550] C完成 <NSThread: 0x600000073880>{number = 3, name = (null)}

*  通过信号量进行线程依赖

- (void)dispatch_semaphore
    {
        NSLog(@"开始");
        //创建一个信号量容器
        dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
        
        //进入调度组
        dispatch_async(dispatch_get_global_queue(0, 0), ^{
            NSLog(@"A开始 %@",[NSThread currentThread]);
            //模拟请求耗时
            sleep(2);
            NSLog(@"A完成 %@",[NSThread currentThread]);
            //事件完成 离开调度组
            dispatch_semaphore_signal(semaphore);
        });
        dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
        
        dispatch_async(dispatch_get_global_queue(0, 0), ^{
            NSLog(@"B开始 %@",[NSThread currentThread]);
            sleep(1);
            NSLog(@"B完成 %@",[NSThread currentThread]);
            dispatch_semaphore_signal(semaphore);
        });
        
        dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
        
        dispatch_async(dispatch_get_global_queue(0, 0), ^{
            NSLog(@"C开始 %@",[NSThread currentThread]);
            sleep(3);
            NSLog(@"C完成 %@",[NSThread currentThread]);
            dispatch_semaphore_signal(semaphore);
        });
        
        dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
        
        NSLog(@"完成");
    }
    
    Log:
    16:06:15.030 GCD[10383:320049] 开始
    16:06:15.031 GCD[10383:320105] A开始 <NSThread: 0x60800007aa80>{number = 3, name = (null)}
    16:06:17.036 GCD[10383:320105] A完成 <NSThread: 0x60800007aa80>{number = 3, name = (null)}
    16:06:17.037 GCD[10383:320105] B开始 <NSThread: 0x60800007aa80>{number = 3, name = (null)}
    16:06:18.042 GCD[10383:320105] B完成 <NSThread: 0x60800007aa80>{number = 3, name = (null)}
    16:06:18.043 GCD[10383:320105] C开始 <NSThread: 0x60800007aa80>{number = 3, name = (null)}
    16:06:21.044 GCD[10383:320105] C完成 <NSThread: 0x60800007aa80>{number = 3, name = (null)}
    16:06:21.045 GCD[10383:320049] 完成

### 控制最大并发数 （信号量） ###

在iOS重写`GCD`之后，`GCD`的最大并发数就一发不可收拾了，之前笔者测试过最大的情况下甚至会开100多条并发线程来处理事务，这个我觉得还是比较浪费的，但是`GCD`又没有给出官方的设置最大并发数的方法，而在苹果新退出的`NSOperation`里面只要设置`maxConcurrentOperationCount`这个属性就能控制最大并发数。不知道是不是苹果的恶意想让我们选择更加面向对象的`NSOperation`，但是目前大部分的iOS开发者还是使用`GCD`的，所以下面跟大家说一下用`GCD`怎么控制最大并发数

@implementation CustomOperationQueue
    
    - (id)initWithConcurrentCount:(int)count
    {
          self = [super init];
          if (self) {
            if (count < 1) count = 5;
            semaphore = dispatch_semaphore_create(count);
            queue = Dispatch_queue_create("cn.jimmypeng", DISPATCH_QUEUE_CONCURRENT);
          }
        return self;
    }
    
    - (id)init 
    {
          return [self initWithConcurrentCount:5];
    }
    
    - (void)addTask:(CallBackBlock)block
    {
        dispatch_async(queue, ^{
           dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
           dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), 0), ^{
                block();
                dispatch_semaphore_signal(semaphore);
            });
        });
    }
    
    @end

在 `addTask:`方法中

1.  当前的初始库存为5
2.  第一次调用`dispatch_semaphore_wait`的时候会直接执行下去，并减少一个库存。每当完成一个任务之后，会执行到`dispatch_semaphore_signal`将库存添加回去。
3.  当执行的任务为非常耗时的操作的时候，库存不能及时地还回去。而`dispatch_semaphore_wait`在仍然执行，库存最后会被减到0，这样`dispatch_semaphore_wait`就只能进行等待直到前面的任务有执行完成将存库有添加回去为止。

如此便完成了并发量的控制！

## 快速遍历 ##

通常我们会用for循环遍历，但是GCD给我们提供了快速迭代的方法`dispatch_apply`，使我们可以同时遍历。比如说遍历0~5这6个数字，for循环的做法是每次取出一个元素，逐个遍历。`dispatch_apply`可以同时遍历多个数字。

dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    
    dispatch_apply(6, queue, ^(size_t index) {
        NSLog(@"%zd------%@",index, [NSThread currentThread]);
    });

# dispatch\_semaphore GCD信号量 #

*  ### dispatch\_semaphore 一共有三个方法 ###

dispatch_semaphore_create => 创建一个信号量
    
    dispatch_semaphore_signal => 发送一个信号
    
    dispatch_semaphore_wait => 等待信号

> 关于信号量，一般可以用停车来比喻。  
> 　　停车场剩余4个车位，那么即使同时来了四辆车也能停的下。如果此时来了五辆车，那么就有一辆需要等待。  
> 　　信号量的值就相当于剩余车位的数目，`dispatch_semaphore_wait`函数就相当于来了一辆车，`dispatch_semaphore_signal`就相当于走了一辆车。停车位的剩余数目在初始化的时候就已经指明了（`dispatch_semaphore_create（long value）`），  
> 　　调用一次`dispatch_semaphore_signal`，剩余的车位就增加一个；调用一次`dispatch_semaphore_wait`剩余车位就减少一个；  
> 　　当剩余车位为0时，再来车（即调用`dispatch_semaphore_wait`）就只能等待。有可能同时有几辆车等待一个停车位。有些车主没有耐心，给自己设定了一段等待时间，这段时间内等不到停车位就走了，如果等到了就开进去停车。而有些车主就像把车停在这，所以就一直等下去。

代码示例：

dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
    
    dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
    
    NSLog(@"等待semaphore");

结果就是， 等待semaphore 这句话永远不会输出。原因有两个

1.  你初始化信号量的时候，并没有库存，也就是你传入的值是0.
2.  你传入等待增加库存的时间是 DISPATCH\_TIME\_FOREVER ，也就是说，除非有 地方运行了 dispatch\_semaphore\_signal 增加了库存，否则我永远等待下 去。 基于上述的两个原因，导致了程序不往下走了。

--------------------

*  ### 信号量的应用 ###

1.测试异步网络请求

在编写单元测试中就可以：

- (void)downloadImageURLWithString:(NSString *)URLString
    {
    // 1
        dispatch_semaphore_t semaphore = dispatch_semaphore_create(0)
        NSURL *url = [NSURL URLWithString:URLString];
        __unused Photo *photo = [[Photo alloc] initwithURL:url withCompletionBlock:^(UIImage *image, NSError *error) {
          if (error) {
                XCTFail(@"%@ failed. %@", URLString, error);
            }
    // 2
          dispatch_semaphore_signal(semaphore);
        }];
    
    // 3
          dispatch_time_t timeoutTime = dispatch_time(DISPATCH_TIME_NOW, 5);
          if (dispatch_semaphore_wait(semaphore, timeoutTime)) {
              XCTFail(@"%@ timed out", URLString);
            }
    }

2.控制并发量

@implementation CustomOperationQueue
    
    - (id)initWithConcurrentCount:(int)count
    {
          self = [super init];
          if (self) {
            if (count < 1) count = 5;
            semaphore = dispatch_semaphore_create(count);
            queue = Dispatch_queue_create("Jake", DISPATCH_QUEUE_CONCURRENT);
          }
        return self;
    }
    
    - (id)init 
    {
          return [self initWithConcurrentCount:5];
    }
    
    - (void)addTask:(CallBackBlock)block
    {
        dispatch_async(queue, ^{
           dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
           dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), 0), ^{
                block();
                dispatch_semaphore_signal(semaphore);
            });
        });
    }
    
    @end

在 `addTask:`方法中  
1.当前的初始库存为5  
2.第一次调用`dispatch_semaphore_wait`的时候会直接执行下去，并减少一个库存。每当完成一个任务之后，会执行到`dispatch_semaphore_signal`将库存添加回去。  
3.当执行的任务为非常耗时的操作的时候，库存不能及时地还回去。而`dispatch_semaphore_wait`在仍然执行，库存最后会被减到0，这样`dispatch_semaphore_wait`就只能进行等待直到前面的任务有执行完成将存库有添加回去为止。

**如此便完成了并发量的控制！**

线程锁的使用：  
以下代码来自[YYModel][]

+ (instancetype)classInfoWithClass:(Class)cls {
        if (!cls) return nil;
        static CFMutableDictionaryRef classCache;
        static CFMutableDictionaryRef metaCache;
        static dispatch_once_t onceToken;
        static dispatch_semaphore_t lock;
        dispatch_once(&onceToken, ^{
            classCache = CFDictionaryCreateMutable(CFAllocatorGetDefault(), 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
            metaCache = CFDictionaryCreateMutable(CFAllocatorGetDefault(), 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
            lock = dispatch_semaphore_create(1);
        });
        dispatch_semaphore_wait(lock, DISPATCH_TIME_FOREVER);
        YYClassInfo *info = CFDictionaryGetValue(class_isMetaClass(cls) ? metaCache : classCache, (__bridge const void *)(cls));
        if (info && info->_needUpdate) {
            [info _update];
        }
        dispatch_semaphore_signal(lock);
        if (!info) {
            info = [[YYClassInfo alloc] initWithClass:cls];
            if (info) {
                dispatch_semaphore_wait(lock, DISPATCH_TIME_FOREVER);
                CFDictionarySetValue(info.isMeta ? metaCache : classCache, (__bridge const void *)(cls), (__bridge const void *)(info));
                dispatch_semaphore_signal(lock);
            }
        }
        return info;
    }

[YYModel]: https://link.jianshu.com/?t=https://github.com/ibireme/YYModel