iOS中的多线程(关于GCD信号量)GCD 中的信号量是指 Dispatch Semaphore，是持有计数的信号。类似

「这是我参与11月更文挑战的第10天，活动详情查看：2021最后一次更文挑战」

GCD 信号量

什么是 Dispatch Semaphore

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

Dispatch Semaphore 的方法

创建信号量创建一个 dispatch_semaphore_ 类型的信号量，并且创建的时候需要指定信号量的大小，当传递的值小于0，信号量将初始化失败返回NULL

dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);

发送信号量发送一个信号，会对信号量进行加 1

dispatch_semaphore_signal(semaphore);

等待信号量

该函数会对信号量进行减 1。如果减 1 后信号量小于 0（即减1前信号量值为0），那么该函数就会一直等待，也就是不返回（相当于阻塞当前线程），直到该函数等待的信号量的值大于等于 1，该函数会对信号量的值进行减1操作，然后返回。

dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);

通常等待信号量和发送信号量的函数是成对出现的。并发执行任务时候，在当前任务执行之前，用 dispatch_semaphore_wait 函数进行等待（阻塞），直到上一个任务执行完毕后且通过 dispatch_semaphore_signal 函数发送信号量（使信号量的值加1），dispatch_semaphore_wait 函数收到信号量之后判断信号量的值大于等于1，会再对信号量的值减1，然后当前任务可以执行，执行完毕当前任务后，再通过 dispatch_semaphore_signal 函数发送信号量（使信号量的值加1），通知执行下一个任务......如此一来，通过信号量，就达到了并发队列中的任务同步执行的要求

用信号量机制使异步线程完成同步操作

在并发队列中的任务，由异步线程执行的顺序是不确定的，两个任务分别由两个线程执行，很难控制哪个任务先执行完，哪个任务后执行完。但有时候确实有这样的需求：两个任务虽然是异步的，但仍需要同步执行。这时候，GCD信号量就可以大显身手了。

异步函数+并发队列实现同步操作

我们知道异步函数 + 串行队列实现任务同步执行更加简单。不过异步函数 + 串行队列的弊端也是非常明显的：因为是异步函数，所以系统会开启新（子）线程，又因为是串行队列，所以系统只会开启一个子线程。这就导致了所有的任务都是在这个子线程中同步的一个一个执行。丧失了并发执行的可能性。虽然可以完成任务，但是却没有充分发挥CPU多核（多线程）的优势

示例：
```
- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event{
    dispatch_queue_t queue = dispatch_queue_create("com.gcd.serialQueue", DISPATCH_QUEUE_SERIAL);

    dispatch_async(queue, ^{
        NSLog(@"任务1:%@",[NSThread currentThread]);
    });
    dispatch_async(queue, ^{
        NSLog(@"任务2:%@",[NSThread currentThread]);
    });
    dispatch_async(queue, ^{
        NSLog(@"任务3:%@",[NSThread currentThread]);
    });
}    
```
log：（三个任务的执行顺序永远是任务1、任务2、任务3，且永远是在同一个子线程被执行）

用GCD的信号量来实现异步线程同步操作

使用信号量实现异步线程同步操作时，虽然任务是一个接一个被同步（说同步并不准确）执行的，但因为是在并发队列，并不是所有的任务都是在同一个线程执行的（所以说同步并不准确）。log中绿框中的任务3是在线程8中被执行的，而任务1和任务2是在线程3中被执行的。这有别于异步函数+串行队列的方式（异步函数+ 串行队列的方式中，所有的任务都是在同一个新线程被串行执行的）

- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event{

    dispatch_semaphore_t sem = dispatch_semaphore_create(0);

    NSLog(@"1、任务1加入并发队列");
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
    
        NSLog(@"任务1:%@",[NSThread currentThread]);
        
        NSLog(@"3、任务1进行信号量加1");
        dispatch_semaphore_signal(sem);
    });

    NSLog(@"2、任务1进行信号量减1");
    dispatch_semaphore_wait(sem, DISPATCH_TIME_FOREVER);
    
    NSLog(@"4、任务2加入并发队列");
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
       
        NSLog(@"任务2:%@",[NSThread currentThread]);
        
        NSLog(@"6、任务2进行信号量加1");
        dispatch_semaphore_signal(sem);
    });
    
    NSLog(@"5、任务2进行信号量减1");
    dispatch_semaphore_wait(sem, DISPATCH_TIME_FOREVER);
    
    NSLog(@"7、任务3加入并发队列");
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        NSLog(@"任务3:%@",[NSThread currentThread]);
        
    });
}

log：（点击事件3次的log，去除了执行顺的log）

log：（单次点击事件的log，包含执行顺序）

Dispatch Semaphore 的使用

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

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

示例：

NSLog(@"currentThread---%@",[NSThread currentThread]);

dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

//创建一个 Semaphore, 并初始化信号的总量
dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);

__block int number = 0;

//异步执行
dispatch_async(queue, ^{
    for (NSInteger i = 0; i<3; i++) {
        NSLog(@"异步执行----%@",[NSThread currentThread]);
    }
    number = 100;

    //发送一个信号，让信号总量加 1
    dispatch_semaphore_signal(semaphore);
});

NSLog(@"异步执行已添加并发队列");

//总信号量减 1
dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);

NSLog(@"执行完毕,number = %d",number);

log：

通过log梳理执行顺序：
1、semaphore 初始化创建信号量为 0
2、异步执行加入队列后，不做等待，接着执行 dispatch_semaphore_wait，这时信号量由0变为-1，当前线程进入等待状态
3、异步执行任务，通过 dispatch_semaphore_signal 方法信号量由-1变为0，当前被阻塞的线程恢复继续执行
4、最后输出：执行完毕,number = 100，这样就实现了线程同步，将异步执行任务转换为同步执行任务

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

示例：

- (void)viewDidLoad{
    semaphore = dispatch_semaphore_create(1);

    self.ticketSurplusCount = 5;
    
    dispatch_queue_t queue = dispatch_queue_create("net.bujige.testQueue1", DISPATCH_QUEUE_CONCURRENT);
    
    __weak typeof(self) weakSelf = self;
    dispatch_async(queue, ^{
        [weakSelf saleTicketSafe];
    });    
    dispatch_async(queue, ^{
        [weakSelf saleTicketSafe];
    });
}

- (void)saleTicket{
    while (1) {
        // 相当于加锁
        dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
        if (self.ticketSurplusCount > 0) {
            self.ticketSurplusCount--;
            NSLog(@"%@", [NSString stringWithFormat:@"剩余票数：%ld 售票员：%@", (long)self.ticketSurplusCount, [NSThread currentThread]]);
            [NSThread sleepForTimeInterval:0.2];
        } else {           
            NSLog(@"票卖完了");
            // 相当于解锁
            dispatch_semaphore_signal(semaphore);
            break;
        }
        // 相当于解锁
        dispatch_semaphore_signal(semaphore);
    }
}

log: