聊一聊你理解的多线程

•NSThread:
–优点：NSThread 比其他两个轻量级，使用简单
–缺点：需要自己管理线程的生命周期、线程同步、加锁、睡眠以及唤醒等。线程同步对数据的加锁会有一定的系统开销

//创建线程方法1
    NSThread *thread = [[NSThread alloc]initWithTarget:self selector:@selector(threadAction:) object:nil];
    [thread start];//开启子线程
    [thread cancel];//取消子线程
     //创建线程方法2-立即在线程中执行任务
    [NSThread detachNewThreadSelector:@selector(threadAction:) toTarget:self withObject:nil];
    //创建线程方法3-在后台子线程中执行任务
    [self performSelectorInBackground:@selector(threadAction:) withObject:nil];

-(void)threadAction:(id*)sender{
    @autoreleasepool {
        //子线程中通知主线程通常使用以下两种办法
        // [self.imageview performSelectorOnMainThread:@selector(updateView:) withObject:nil waitUntilDone:YES];

        // [self.imageview performSelector:@selector(updateView:) onThread:[NSThread mainThread] withObject:nil waitUntilDone:YES];
    }
}

线程间通讯

线程下载完图片后怎么通知主线程更新界面呢？

performSelectorOnMainThread是NSObject的方法，除了可以更新主线程的数据外，还可以更新其他线程的

两种锁，一种NSCondition ，一种是：NSLock

 // 锁对象   
    theLock = [[NSLock alloc] init];   
    ticketsCondition = [[NSCondition alloc] init];
        // 上锁   
//      [ticketsCondition lock];   
        [theLock lock];   
//中间写代码

  //开锁
//      [ticketsCondition unlock]; 
        [theLock unlock]; 

可以通过[ticketsCondition signal]; 发送信号的方式，在一个线程唤醒另外一个线程的等待。
NSCondition的wait其实就是在线程内等待一个信号量, 信号量出现时就继续, 否则一直等下去
也可以用- (BOOL)waitUntilDate:(NSDate *)limit; 
这个在给定的时间到达时仍未有信号量出现, 就自动继续了.
如果用户给出信号量来触发继续的话, 会返回1
如果超时触发继续, 返回0
theLock = [[NSLock alloc] init];   
    // 锁对象   
    ticketsCondition = [[NSCondition alloc] init];   

        [ticketsCondition lock];   
        [NSThread sleepForTimeInterval:3];   
        [ticketsCondition signal];   //唤醒另一个线程
        [ticketsCondition unlock];   

        // 上锁   
        [ticketsCondition lock];   
        [ticketsCondition wait];   

        [theLock lock];   
     //要做的事情
        [theLock unlock];   

        [ticketsCondition unlock];  

其他同步
我们可以使用指令 @synchronized 来简化 NSLock的使用，这样我们就不必显示编写创建NSLock,加锁并解锁相关代码。

    @synchronized(anObj) 
    { 
        // Everything between the braces is protected by the @synchronized directive. 
    } 
还有其他的一些锁对象，
比如：循环锁NSRecursiveLock，条件锁NSConditionLock，分布式锁NSDistributedLock等等，可以自己看官方文档学习


•NSOperation：
–不需要关心线程管理，数据同步的事情，可以把精力放在自己需要执行的操作上
–NSOperation是面向对象的

  //NSOperationQueue
     //两种操作-（操作本身跟多线程关系不大）
     //NSInvocationOperation
     //NSBlockOperation
    NSInvocationOperation *inop = [[NSInvocationOperation alloc]initWithTarget:self selector:@selector(inopAction:) object:nil];
    //[inop start];
    NSBlockOperation *blop = [NSBlockOperation blockOperationWithBlock:^{
        @autoreleasepool { NSLog(@"blop"); }   }];
    
    //队列
    NSOperationQueue *queue = [[NSOperationQueue alloc]init];
    
    //1的话顺序执行
    //同时执行最大操作数
    queue.maxConcurrentOperationCount = 3;
    //依赖关系
    [inop addDependency:blop];//blop执行完，才能执行inop
    //向队列添加操作
    [queue addOperation:inop];
    [queue addOperation:blop];

-(void)inopAction:(id)sender{
    @autoreleasepool { NSLog(@"inop"); }
    }
   

关于并发数
（1）并发数:同时执⾏行的任务数.比如,同时开3个线程执行3个任务,并发数就是3
（2）最大并发数：同一时间最多只能执行的任务的个数。
（3）最⼤大并发数的相关⽅方法
- (NSInteger)maxConcurrentOperationCount;
- (void)setMaxConcurrentOperationCount:(NSInteger)cnt; 
说明：如果没有设置最大并发数，那么并发的个数是由系统内存和CPU决定的，可能内存多久开多一点，内存少就开少一点。
注意：num的值并不代表线程的个数，仅仅代表线程的ID。
提示：最大并发数不要乱写（5以内），不要开太多，一般以2~3为宜，因为虽然任务是在子线程进行处理的，但是cpu处理这些过多的子线程可能会影响UI，让UI变卡。

•GCD：
–Grand Central Dispatch是由苹果开发的一个多核编程的解决方案。iOS4.0+才能使用，是替代NSThread， NSOperation的高效和强大的技术
–GCD是基于C语言的

GCD的工作原理是：让程序平行排队的特定任务，根据可用的处理资源，安排他们在任何可用的处理器核心上执行任务。
一个任务可以是一个函数(function)或者是一个block。 GCD的底层依然是用线程实现，不过这样可以让程序员不用关注实现的细节。
GCD中的FIFO队列称为dispatch queue，它可以保证先进来的任务先得到执行
dispatch queue分为下面三种：
Serial     
又称为private dispatch queues，同时只执行一个任务。Serial queue通常用于同步访问特定的资源或数据。当你创建多个Serial queue时，虽然它们各自是同步执行的，但Serial queue与Serial queue之间是并发执行的。
Concurrent
又称为global dispatch queue，可以并发地执行多个任务，但是执行完成的顺序是随机的。
Main dispatch queue
它是全局可用的serial queue，它是在应用程序主线程上执行任务的。

The main queue: 与主线程功能相同。实际上,提交⾄至main queue的任务会在主线程中执⾏行。main queue可以调⽤用dispatch_get_main_queue()来获得。因为mainqueue是与主线程相关的,所以这是⼀一个串⾏行队列。
Global queues: 全局队列是并发队列,并由整个进程共享。进程中存在三个全局队列:⾼高、中(默认)、低、后台四个优先级队列。可以调⽤用dispatch_get_global_queue函数传⼊入优先级来访问队列。优先级:
#define DISPATCH_QUEUE_PRIORITY_HIGH 2
#define DISPATCH_QUEUE_PRIORITY_DEFAULT 0
#define DISPATCH_QUEUE_PRIORITY_LOW (-2)
#define DISPATCH_QUEUE_PRIORITY_BACKGROUND INT16_MIN

dispatch_sync(),同步添加操作。等待添加进队列里面的操作完成之后再继续执行。调用以后等到block执行完以后才返回 ，dispatch_sync()会阻塞当前线程。
dispatch_async ,异步添加进任务队列，调用以后立即返回，它不会做任何等待

在多线程开发当中，程序员只要将想做的事情定义好，并追加到DispatchQueue（派发队列）当中就好了。
　　派发队列分为两种，一种是串行队列（SerialDispatchQueue），一种是并行队列（ConcurrentDispatchQueue）。
　　一个任务就是一个block，比如，将任务添加到队列中的代码是：
　　1 dispatch_async(queue, block);
　　当给queue添加多个任务时，如果queue是串行队列，则它们按顺序一个个执行，同时处理的任务只有一个。
　　当queue是并行队列时，不论第一个任务是否结束，都会立刻开始执行后面的任务，也就是可以同时执行多个任务。
　　但是并行执行的任务数量取决于XNU内核，是不可控的。比如，如果同时执行10个任务，那么10个任务并不是开启10个线程，线程会根据任务执行情况复用，由系统控制。

延时的实现

 //第一种NSThread延时
    [NSThread sleepForTimeInterval:3];//延时3秒-阻塞主线程
    //第二种
    [self performSelector:@selector(dosth) withObject:nil afterDelay:2];//延时3秒执行，不会阻塞主线程

    //第三种GCD 3秒回到主线程执行 不会阻塞主线程
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(33 * NSEC_PER_SEC)),

                   dispatch_get_main_queue(), ^{NSLog(@"第三种");} );

    //第四种 GCD
    dispatch_queue_t qq = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)4*NSEC_PER_SEC), qq, ^{
        NSLog(@"第四种");
    });

-(void)dosth{
    NSLog(@"第二种");
}

dispatch_barrier_async的使用
dispatch_barrier_async是在前面的任务执行结束后它才执行，而且它后面的任务等它执行完成之后才会执行


dispatch_group_async的使用
dispatch_group_async可以实现监听一组任务是否完成，完成后得到通知执行其他的操作。这个方法很有用，比如你执行三个下载任务，当三个任务都下载完成后你才通知界面说完成的了。

dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_group_t group = dispatch_group_create();
dispatch_group_async(group, queue, ^{
    [NSThread sleepForTimeInterval:1];
    NSLog(@"group1");
});
dispatch_group_async(group, queue, ^{
    [NSThread sleepForTimeInterval:2];
    NSLog(@"group2");
});
dispatch_group_async(group, queue, ^{
    [NSThread sleepForTimeInterval:3];
    NSLog(@"group3");
});
dispatch_group_notify(group, dispatch_get_main_queue(), ^{
    NSLog(@"updateUi");
});
dispatch_release(group);

//重复执行
  //放到全局队列才执行
  dispatch_apply(10, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^(size_t t) {
      NSLog(@"重复执行,%ld",t);
  });

Operation、GCD对比:

优点：不需要关心线程管理，数据同步的事情。
两者区别：
NSOperationQueue可以方便的管理并发、NSOperation之间的优先级。
GCD主要与block结合使用。代码简洁高效

1. 性能:GCD更接近底层，而NSOperationQueue则更高级抽象，所以GCD在追求性能的底层操作来说，是速度最快的。这取决于使用Instruments进行代码性能分析，如有必要的话

2. 从异步操作之间的事务性，顺序行，依赖关系。GCD需要自己写更多的代码来实现，而NSOperationQueue已经内建了这些支持

3. 如果异步操作的过程需要更多的被交互和UI呈现出来，NSOperationQueue会是一个更好的选择。底层代码中，任务之间不太互相依赖，而需要更高的并发能力，GCD则更有优势

GCD

Grand Central Dispatch (GCD)是 Apple 开发的一个多核编程的解决方法。该方法在 Mac OS X 10.6 雪豹中首次推出，并随后被引入到了 iOS4.0中。GCD 是一个替代诸如 NSThread, NSOperationQueue, NSInvocationOperation 等技术的很高效和强大的技术。
GCD 和 block的配合使用，可以方便地进行多线程编程。

任务和队列

1.任务分为同步任务和异步任务，队列分为串行和并行
2.同步任务不会开线程，异步任务会开线程

- (void)sync_queue:(dispatch_queue_t)queue{

    //同步任务
    dispatch_sync(queue, ^{
        NSLog(@"同步1 - %@",[NSThread currentThread]);
    });
    
    dispatch_sync(queue, ^{
        NSLog(@"同步2 - %@",[NSThread currentThread]);
    });
    
    dispatch_sync(queue, ^{
        NSLog(@"同步3 - %@",[NSThread currentThread]);
    });
    
    dispatch_sync(queue, ^{
        NSLog(@"同步4 - %@",[NSThread currentThread]);
    });
}

- (void)async_queue:(dispatch_queue_t)queue{
    
    //异步任务
    dispatch_async(queue, ^{
        NSLog(@"异步1 - %@",[NSThread currentThread]);
    });
    
    dispatch_async(queue, ^{
        NSLog(@"异步2 - %@",[NSThread currentThread]);
    });
    
    dispatch_async(queue, ^{
        NSLog(@"异步3 - %@",[NSThread currentThread]);
    });
    
    dispatch_async(queue, ^{
        NSLog(@"异步4 - %@",[NSThread currentThread]);
    });
}

3.串行队列一个一个的执行，并行队列一起执行

同步任务

dispatch_sync(<#dispatch_queue_t _Nonnull queue#>, <#^(void)block#>)

异步任务

dispatch_async(<#dispatch_queue_t _Nonnull queue#>, <#^(void)block#>)

主队列

dispatch_queue_t mainQueue = dispatch_get_main_queue();

全局并发队列

dispatch_queue_t globalQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

自定义串行队列

dispatch_queue_t serialQueue = dispatch_queue_create("wanglei", NULL);

自定义并行队列

dispatch_queue_t concurrentQueue = dispatch_queue_create("king", DISPATCH_QUEUE_CONCURRENT);

同步主线程会卡死，造成死循环

[self sync_queue:mainQueue];

异步主线程不会开线程，顺序执行

[self async_queue:mainQueue];

同步全局并发不会开线程，顺序执行

[self sync_queue:globalQueue];

异步全局并发会开线程，乱序执行

[self async_queue:globalQueue];

同步串行不会开线程，顺序执行

[self sync_queue:serialQueue];

异步串行会开线程，顺序执行

[self async_queue:serialQueue];

同步并行不会开线程，顺序执行

[self sync_queue:concurrentQueue];

异步并行会开线程，乱序执行

[self async_queue:concurrentQueue];




线程间通信

#pragma mark - 线程间通讯
- (void)threadCommunication{

    //主队列
    dispatch_queue_t mainQueue = dispatch_get_main_queue();
    //全局并发队列
    dispatch_queue_t globalQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    
    dispatch_async(globalQueue, ^{
        
        NSURL *url = [NSURL URLWithString:@""];
        NSData *data = [[NSData alloc]initWithContentsOfURL:url];
        NSLog(@"%@",[NSThread currentThread]);
        
        dispatch_async(mainQueue, ^{
            
            data;
            //在这里刷新UI
            NSLog(@"mainQueue -- %@",[NSThread currentThread]);
        });
    });
}

GCD创建单例

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

    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        NSLog(@"只执行一次");
    });
}

GCD创建分组任务

- (void)dispatch_group{

    // 创建一个分组
    dispatch_group_t group = dispatch_group_create();
    
    // 全局队列
    dispatch_queue_t globalQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    
    // 第一个参数: 任务所在的分组
    // 第二个参数: 任务所在的队列
    
    dispatch_group_async(group, globalQueue, ^{
        NSLog(@"分组任务1");
    });
    
    dispatch_group_async(group, globalQueue, ^{
        NSLog(@"分组任务2");
    });
    
    // 当上面两个任务都完成以后，会执行这个方法，我们在这里处理我们的需求
    dispatch_group_notify(group, globalQueue, ^{
        NSLog(@"上面分组任务完成后，才会执行");
    });
}

GCD延迟操作

- (void)dosomethingByTime{

    // 延迟加载函数
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(10 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        NSLog(@"延迟10s加载");
    });
    
    // 自定义并行队列
    dispatch_queue_t concurrentQueue = dispatch_queue_create("wanglei", DISPATCH_QUEUE_CONCURRENT);
    
    dispatch_async(concurrentQueue, ^{
        NSLog(@"dispatch_async - 1-%@",[NSThread currentThread]);
    });
    
    dispatch_async(concurrentQueue, ^{
        NSLog(@"dispatch_async - 2-%@",[NSThread currentThread]);
    });
    
    // dispatch_barrier_async 使用于并行环境下
    // 使用dispatch_barrier_async添加的任务会在之前的block全部运行完毕之后，才会继续执行。保证对非线程安全的对象进行正确的操作
    // 运行完dispatch_barrier_async的block才会执行后面的任务
    // dispatch_barrier_async所在的线程跟前一个任务是同一条线程
    dispatch_barrier_async(concurrentQueue, ^{
        NSLog(@"dispatch_barrier_async-%@",[NSThread currentThread]);
    });
    
    dispatch_barrier_async(concurrentQueue, ^{
        NSLog(@"dispatch_barrier_async- 3 -%@",[NSThread currentThread]);
    });
    
    dispatch_barrier_async(concurrentQueue, ^{
        NSLog(@"dispatch_barrier_async- 4 -%@",[NSThread currentThread]);
    });

}

GCD下载图片及合成

- (void)drawRectImage{

    // 创建全局并发队列
    dispatch_queue_t globalQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    
    // 异步下载
    dispatch_async(globalQueue, ^{
        
        // 下载第一张图片
        NSURL *url1 = [NSURL URLWithString:@"http://pic6.huitu.com/res/20130116/84481_20130116142820494200_1.jpg"];
        NSData *data1 = [NSData dataWithContentsOfURL:url1];
        UIImage *image1 = [UIImage imageWithData:data1];
        
        // 下载第二张图片
        NSURL *url2 = [NSURL URLWithString:@"http://g.hiphotos.baidu.com/image/pic/item/c2cec3fdfc03924578c6cfe18394a4c27c1e25e8.jpg"];
        NSData *data2 = [NSData dataWithContentsOfURL:url2];
        UIImage *image2 = [UIImage imageWithData:data2];
        
        // 合并图片
        // 开启一个位图上下文
        UIGraphicsBeginImageContextWithOptions(image1.size, NO, 0.0);
        
        // 绘制第一张图片
        CGFloat image1Width = image1.size.width;
        CGFloat image1Height = image1.size.height;
        [image1 drawInRect:CGRectMake(0, 0, image1Width, image1Height)];
        
        // 绘制第二张图片
        CGFloat image2Width = image2.size.width * 0.5;
        CGFloat image2Height = image2.size.height * 0.5;
        CGFloat image2Y = image1Height - image2Height;
        [image2 drawInRect:CGRectMake(0, image2Y, image2Width, image2Height)];
        
        // 得到上下文中的图片
        UIImage *fullImage = UIGraphicsGetImageFromCurrentImageContext();
        
        // 结束上下文
        UIGraphicsEndImageContext();
        
        // 回到主线程显示图片
        
        dispatch_queue_t mainQueue = dispatch_get_main_queue();
        dispatch_async(mainQueue, ^{
            self.imageView.image = fullImage;
        });
    });
}

dispatch_source_t

//dispatch_source_t 默认是挂起的,需要dispatch_resume()
//这个和子线程处理数据主线程更新界面的优点在于,当主线程比较空闲一起更新界面.效率更高
dispatch_source_t source = dispatch_source_create(DISPATCH_SOURCE_TYPE_DATA_ADD, 0, 0, dispatch_get_main_queue());

dispatch_source_set_event_handler(source, ^{
    NSLog(@"%ld",dispatch_source_get_data(source));
});

dispatch_resume(source);

dispatch_apply(100, dispatch_get_global_queue(0, 0), ^(size_t index) {
    // do some work on data at index
    dispatch_source_merge_data(source, 1);
});

GCD实现的验证码倒计时

- (void)btnClick{
     [_btn setTitle:@"重发(60s)" forState:UIControlStateNormal];
    __block int timeout=59; //倒计时时间
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    dispatch_source_t _timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0,queue);
    dispatch_source_set_timer(_timer,dispatch_walltime(NULL, 0),1.0*NSEC_PER_SEC, 0); //每秒执行
    dispatch_source_set_event_handler(_timer, ^{
        if(timeout<=0){ //倒计时结束，关闭
            
            dispatch_source_cancel(_timer);
            dispatch_async(dispatch_get_main_queue(), ^{
                //设置界面的按钮显示 根据自己需求设置
                self.btn.userInteractionEnabled = YES;
                [self.btn setTitle:@"获取验证码" forState:UIControlStateNormal];
                
            });
        }else{
            int seconds = timeout % 60;
            NSString *strTime = [NSString stringWithFormat:@"%.2d", seconds];
            dispatch_async(dispatch_get_main_queue(), ^{
                //设置界面的按钮显示 根据自己需求设置
                [UIView beginAnimations:nil context:nil];
                [UIView setAnimationDuration:1];
                [self.btn setTitle:[NSString stringWithFormat:@"重发(%@秒)",strTime] forState:UIControlStateNormal];
                
                [UIView commitAnimations];
                self.btn.userInteractionEnabled = NO;
                
            });
            timeout--;
        }
    });
    
    dispatch_resume(_timer);
    



}

dispatch_barrier_async

//    作用是在并行队列中，等待前面两个操作并行操作完成，再执行后面的输出
    dispatch_queue_t queue6 =dispatch_queue_create("gcdtest.zfl.demo",DISPATCH_QUEUE_CONCURRENT);

    dispatch_async(queue6, ^{

        [NSThread sleepForTimeInterval:2];

        NSLog(@"dispatch_async1");

    });

    dispatch_async(queue6, ^{

        NSLog(@"dispatch_async2");

    });

    dispatch_barrier_async(queue6, ^{

        NSLog(@"dispatch_barrier_async");

    });

    dispatch_async(queue6, ^{

        NSLog(@"dispatch_async3");

信号量概述（引用百度百科）：

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

　　抽象的来讲，信号量的特性如下：信号量是一个非负整数（车位数），所有通过它的线程/进程（车辆）都会将该整数减一（通过它当然是为了使用资源），当该整数值为零时，所有试图通过它的线程都将处于等待状态。在信号量上我们定义两种操作： Wait（等待） 和 Release（释放）。当一个线程调用Wait操作时，它要么得到资源然后将信号量减一，要么一直等下去（指放入阻塞队列），直到信号量大于等于一时。Release（释放）实际上是在信号量上执行加操作，对应于车辆离开停车场，该操作之所以叫做“释放”是因为释放了由信号量守护的资源。

 

Demo解析 

    //    创建一个信号量，值为0        
    dispatch_semaphore_t sema = dispatch_semaphore_create(0);
        //    在一个操作结束后发信号，这会使得信号量+1
        ABAddressBookRequestAccessWithCompletion(addressBook, ^(bool granted, CFErrorRef error) {

            dispatch_semaphore_signal(sema);

        });
    //    一开始执行到这里信号量为0，线程被阻塞，直到上述操作完成使信号量+1,线程解除阻塞
    dispatch_semaphore_wait(sema, DISPATCH_TIME_FOREVER);

    //    创建一个组 
    dispatch_group_t group = dispatch_group_create();
    //    创建信号 信号量为10
    dispatch_semaphore_t semaphore = dispatch_semaphore_create(10);
    //    取得默认的全局并发队列
    dispatch_queue_t queue =    dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    for(inti = 0; i < 100; i++)
    {
        //    由于信号量为10 队列里面最多会有10个人任务被执行，
       dispatch_semaphore_wait(semaphore,DISPATCH_TIME_FOREVER);
        //    任务加到组内被监听
        dispatch_group_async(group, queue, ^{
            NSLog(@"%i",i);
            sleep(2);
            dispatch_semaphore_signal(semaphore);
        });
    }
    //    等待组内所有任务完成，否则阻塞
    dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
    dispatch_release(group);
    dispatch_release(semaphore);