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中的使用

1. 限制最大的并发数

   //最多只有三个任务在执行
   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 结束
   */
   

2. 异步操作 同步执行

   //这是串行队列
   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 开始 线程:{number = 2, name = (null)}
    任务0 结束 线程:{number = 2, name = (null)}
    任务1 开始 线程:{number = 2, name = (null)}
    任务1 结束 线程:{number = 2, name = (null)}
    任务2 开始 线程:{number = 2, name = (null)}
    任务2 结束 线程:{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 开始 线程:{number = 2, name = (null)}
    任务0 结束 线程:{number = 2, name = (null)}
    任务1 开始 线程:{number = 2, name = (null)}
    任务1 结束 线程:{number = 2, name = (null)}
    任务2 开始 线程:{number = 2, name = (null)}
    任务2 结束 线程:{number = 2, name = (null)}
   */
   

3. 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 开始 线程:{number = 2, name = (null)}
    任务1 结束 线程:{number = 2, name = (null)}
    任务2 开始 线程:{number = 3, name = (null)}
    任务2 结束 线程:{number = 3, name = (null)}
    任务3 开始 线程:{number = 4, name = (null)}
    任务3 结束 线程:{number = 4, name = (null)}
    group内的三个任务执行完毕了
   */
   
   

4. 多线程中给数组添加元素

   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的值