iOS GCD信号量的使用

什么是信号量

信号量是一种特殊的变量，访问具有原子性。当信号量大于0时执行wait操作信号量会减1，当信号量为0是，程序会等待，直到信号量大于0时，才继续执行。我们可以使用信号量来解决线程之间的同步问题。

iOS 中信号量的相关的方法

dispatch_semaphore_t dispatch_semaphore_create(long value); 初始化一个值为value的信号量
- 当传递的值等于0时，对与协调两个线程很有用，能够完成特定的事件。
- 当传递的值大于0时，对与管理一个资源等于value的资源池时很有用，能有效的维护资源的安全。
- 当传递的值小于0时，将直接返回null。
long dispatch_semaphore_wait(dispatch_semaphore_t dsema, dispatch_time_t timeout); 当信号量的值大于0时，信号量会减1，当信号量的值等于0时，阻塞线程直到该信号量的值大于0或者达到等待时间。
long dispatch_semaphore_signal(dispatch_semaphore_t dsema); 释放信号量，使得该信号量的值加1

//信号量在swift中实现
open class DispatchSemaphore : DispatchObject {
}

/// dispatch_semaphore
extension DispatchSemaphore {

    public func signal() -> Int

    public func wait()

    public func wait(timeout: DispatchTime) -> DispatchTimeoutResult

    public func wait(wallTimeout: DispatchWallTime) -> DispatchTimeoutResult
}
extension DispatchSemaphore {
    //初始化一个值为value的信号量
    @available(macOS 10.6, *)
    public /*not inherited*/ init(value: Int)
}

信号量在iOS中的使用

限制最大的并发数

//最多只有三个任务在执行
dispatch_semaphore_t semaphore = dispatch_semaphore_create(3);
//创建一个并发队列
dispatch_queue_t queue = dispatch_queue_create("并发队列", DISPATCH_QUEUE_CONCURRENT);
//总共有6个任务，一次执行3个任务，3个任务结束，接着再执行3个任务，直到任务都完成
for (int i = 0; i < 6 ; i++) {
    dispatch_async(queue, ^{
        dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
        NSLog(@"任务%d 开始",i);
        [NSThread sleepForTimeInterval:2];
        NSLog(@"任务%d 结束",i);
        dispatch_semaphore_signal(semaphore);
    });
}
/*输出
 任务1 开始
 任务0 开始
 任务2 开始
 任务0 结束
 任务2 结束
 任务1 结束
 任务3 开始
 任务4 开始
 任务5 开始
 任务3 结束
 任务5 结束
 任务4 结束
*/

let semaphore = DispatchSemaphore.init(value: 3)
let queue = DispatchQueue.init(label: "并发队列",attributes: .concurrent)
for i in 0..<6 {
    queue.async {
        semaphore.wait()
        print("任务\(i) 开始")
        Thread.sleep(forTimeInterval: 2)
        print("任务\(i) 结束")
        semaphore.signal()
    }
}

/*
任务0 开始
任务2 开始
任务1 开始
任务0 结束
任务1 结束
任务2 结束
任务3 开始
任务4 开始
任务5 开始
任务3 结束
任务5 结束
任务4 结束
*/

异步操作同步执行

//这是串行队列
dispatch_queue_t queue = dispatch_queue_create("串行队列", DISPATCH_QUEUE_SERIAL);
for (int i = 0; i < 6 ; i++) {
    dispatch_async(queue, ^{
        NSLog(@"任务%d 开始 线程:%@",i,[NSThread currentThread]);
        [NSThread sleepForTimeInterval:1];
        NSLog(@"任务%d 结束 线程:%@",i,[NSThread currentThread]);
    });
}
/*
 任务0 开始 线程:<NSThread: 0x100705800>{number = 2, name = (null)}
 任务0 结束 线程:<NSThread: 0x100705800>{number = 2, name = (null)}
 任务1 开始 线程:<NSThread: 0x100705800>{number = 2, name = (null)}
 任务1 结束 线程:<NSThread: 0x100705800>{number = 2, name = (null)}
 任务2 开始 线程:<NSThread: 0x100705800>{number = 2, name = (null)}
 任务2 结束 线程:<NSThread: 0x100705800>{number = 2, name = (null)}
*/

//这是并发队列使用信号量
dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
dispatch_queue_t queue = dispatch_queue_create("并发队列", DISPATCH_QUEUE_CONCURRENT);
for (int i = 0; i < 3 ; i++) {
    dispatch_async(queue, ^{
        NSLog(@"任务%d 开始 线程:%@",i,[NSThread currentThread]);
        [NSThread sleepForTimeInterval:1];
        NSLog(@"任务%d 结束 线程:%@",i,[NSThread currentThread]);
        dispatch_semaphore_signal(semaphore);
    });
    dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
}
/*
 任务0 开始 线程:<NSThread: 0x10043da10>{number = 2, name = (null)}
 任务0 结束 线程:<NSThread: 0x10043da10>{number = 2, name = (null)}
 任务1 开始 线程:<NSThread: 0x10043da10>{number = 2, name = (null)}
 任务1 结束 线程:<NSThread: 0x10043da10>{number = 2, name = (null)}
 任务2 开始 线程:<NSThread: 0x10043da10>{number = 2, name = (null)}
 任务2 结束 线程:<NSThread: 0x10043da10>{number = 2, name = (null)}
*/

dispatch group异步线程同步执行

dispatch_queue_t queue = dispatch_queue_create("并发队列", DISPATCH_QUEUE_CONCURRENT);
dispatch_group_t group = dispatch_group_create();
dispatch_semaphore_t semaphore = dispatch_semaphore_create(1);
dispatch_group_enter(group);
dispatch_group_async(group, queue, ^{
    dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
    NSLog(@"任务1 开始 线程:%@",[NSThread currentThread]);
    dispatch_async(dispatch_queue_create("并发队列", DISPATCH_QUEUE_CONCURRENT), ^{
        [NSThread sleepForTimeInterval:1];
        NSLog(@"任务1 结束 线程:%@",[NSThread currentThread]);
        dispatch_semaphore_signal(semaphore);
        dispatch_group_leave(group);
    });
});
// dispatch_group_enter(group); 相当于进入group block 加1
// dispatch_group_leave(group); //相当于退出group block 减1
// 这两个方法是为了保证group block中即使有异步block，也能准确的调用dispatch_group_notify
//只有dispatch_group_enter，dispatch_group_leave 成对调用时才能最终调用dispatch_group_notify
dispatch_group_enter(group);
dispatch_group_async(group, queue, ^{
    dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
    NSLog(@"任务2 开始 线程:%@",[NSThread currentThread]);
    dispatch_async(dispatch_queue_create("并发队列", DISPATCH_QUEUE_CONCURRENT), ^{
        [NSThread sleepForTimeInterval:1];
        NSLog(@"任务2 结束 线程:%@",[NSThread currentThread]);
        dispatch_semaphore_signal(semaphore);
        dispatch_group_leave(group);
    });

});

dispatch_group_enter(group);
dispatch_group_async(group, queue, ^{
    dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
    NSLog(@"任务3 开始 线程:%@",[NSThread currentThread]);
    dispatch_async(dispatch_queue_create("并发队列", DISPATCH_QUEUE_CONCURRENT), ^{
        [NSThread sleepForTimeInterval:1];
        NSLog(@"任务3 结束 线程:%@",[NSThread currentThread]);
        dispatch_semaphore_signal(semaphore);
        dispatch_group_leave(group);
    });
});

dispatch_group_notify(group, queue, ^{
    NSLog(@"group内的三个任务执行完毕了");
});
        
/*输出
 任务1 开始 线程:<NSThread: 0x10048e6d0>{number = 2, name = (null)}
 任务1 结束 线程:<NSThread: 0x10048e6d0>{number = 2, name = (null)}
 任务2 开始 线程:<NSThread: 0x102a063f0>{number = 3, name = (null)}
 任务2 结束 线程:<NSThread: 0x102a063f0>{number = 3, name = (null)}
 任务3 开始 线程:<NSThread: 0x1029252e0>{number = 4, name = (null)}
 任务3 结束 线程:<NSThread: 0x1029252e0>{number = 4, name = (null)}
 group内的三个任务执行完毕了
*/

多线程中给数组添加元素

dispatch_queue_t queue = dispatch_queue_create("并发队列", DISPATCH_QUEUE_CONCURRENT);
NSMutableArray *array = [NSMutableArray array];
for (int i = 0; i < 10000; i++) {
    dispatch_async(queue, ^{
        NSLog(@"添加的值:%d  当前线程%@",i,[NSThread currentThread]);
      //在不同线程中同时操作数组，如果不使用信号量来进行控制，很有可能因为内存错误而导致程序异常崩溃。因为array的增删操作并不是线程安全的，可能在同一时间操作同一块内存地址。
        [array addObject:@(i)];
    });
}
//输出 在运行的某个时间点发生崩溃


//******************************************
//下面这种写法也是错误的
dispatch_queue_t queue = dispatch_queue_create("并发队列", DISPATCH_QUEUE_CONCURRENT);
NSMutableArray *array = [NSMutableArray array];
dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
  for (int i = 0; i < 10000; i++) {
      dispatch_async(queue, ^{
         //每次信号量加1，根本就无法阻塞数组的添加操作，那么这信号量加的就没有意义依旧会发生崩溃
          dispatch_semaphore_signal(semaphore);
          NSLog(@"添加的值:%d  当前线程%@",i,[NSThread currentThread]);
          [array addObject:@(i)];
          dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
      });
  }

//输出 在运行的某个时间点发生崩溃

 dispatch_queue_t queue = dispatch_queue_create("并发队列", DISPATCH_QUEUE_CONCURRENT);
 NSMutableArray *array = [NSMutableArray array];
 dispatch_semaphore_t semaphore = dispatch_semaphore_create(1);
 for (int i = 0; i < 10000; i++) {
   dispatch_async(queue, ^{
       dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
       NSLog(@"添加的值:%d  当前线程%@",i,[NSThread currentThread]);
       [array addObject:@(i)];
       dispatch_semaphore_signal(semaphore);
   });
 }
 //输出 正确的输出0-9999的值