//例子
- (void)nscondition_test {
    for (int i = 0; i < 50; i ++) {
        dispatch_async(dispatch_get_global_queue(0, 0), ^{
            [self lg_production];
        });
    }
    for (int i = 0; i < 100; i ++) {
        dispatch_async(dispatch_get_global_queue(0, 0), ^{
            [self lg_consumption];
        });
    }
}

- (void)lg_production {
    [self.iCondition lock];
    self.count ++;
    NSLog(@"生产了一个产品,现有产品 : %d个",self.count);
    [self.iCondition signal];
    [self.iCondition unlock];
}

- (void)lg_consumption { //虚假唤醒
    [self.iCondition lock];
    while (self.count == 0) {//if是虚假唤醒，可以改为while就不会虚假唤醒
        [self.iCondition wait];
    }
    self.count --;
    NSLog(@"消费了一个产品,现有产品: %d个",self.count);
    [self.iCondition unlock];
}

NSConditionLock是基于NSCondition的封装
//一些基本操作
- (void)lock 
//加锁

- (void)unlock 
//解锁

- (instancetype)initWithCondition:(NSinteger)
//初始化一个。NSConditionLock对象（设置了初始值）

@property(readonly) NSInteger condition 
//锁的条件

- (void)lockWhenCondition:(NSInteger)conditio
//满足条件时加锁

- (BOOL)tryLock
//尝试加锁

- (BOOL)tryLockWhenCondition
//如果接受对象的condition与给定的condition相等，则尝试获取锁，不足塞线程

- (void)unlockWithCondition:(NSInteger)condition
//解锁，重置锁的条件

- (BOOL)lockBeforDate:(NSDate *)
//limit在指定时间点之前获取锁

- (BOOL)lockWhenCondition:(NSInteger)condition beforeDate:(NSDate *)
//limit在指定的时间前获取锁

@property (nullable ,copy) NSString *name 
//锁名称

//例子
- (void)lg_testConditonLock{
    //如何让123变的顺序
    //第一种方法：使用信号量
    //第二种方法：使用NSConditonLock
    self.iConditionLock = [[NSConditionLock alloc] initWithCondition:3];
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        //只有与初始化值相同的时候锁才能初始化
        [self.iConditionLock lockWhenCondition:3];
        NSLog(@"线程 1");
        [self.iConditionLock unlockWithCondition:2];
    });
    
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        [self.iConditionLock lockWhenCondition:2];
        NSLog(@"线程 2");
        [self.iConditionLock unlockWithCondition:1];
    });
    
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        [self.iConditionLock lockWhenCondition:1];
        NSLog(@"线程 3");
        [self.iConditionLock unlockWithCondition:0];
    });
}

NSRecursiveLock是递归锁，在递归函数的时候使用
//一些操作

- (void)lock 
//加锁

- (void)unlock 
//解锁

- (BOOL)tryLock 
//尝试加锁。成功返回YES，失败返回NO

- (BOOL)lockBeforeDete:(NSDate *)limit 
//在指定时间点之前获取锁，能够获取返回YES，获取不到返回NO

@property (nullable ,copy) NSString *name 
//锁名称。

-(void)recursiveLock_test {
    
    [self.iRecursiveLock lock];
    self.count --;
    NSLog(@"%d",self.count);
    [self.iRecursiveLock unlock];
}

//注意点 递归锁不可以在多个线程下递归调用
- (void)recursiveTest {
    //如果这里加for循环async时
    //因为这个锁是递归锁，他可以在同一时刻能够被多个线程所拥有
    //但解锁的时候需要保证该锁不被其他线程所拥有，那么就会导致多个线程此时就会产生相互等待彼此解锁的死锁情况
    //所以递归锁不能在多个线程下递归调用 此时就可以用@synchronized
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        static void (^recursiveMethod)(int);
        recursiveMethod = ^(int value){
            if (value > 0) {
                //@synchronized(self)
                [self.iRecursiveLock lock];
                NSLog(@"%d",value);
                recursiveMethod(value - 1);
                [self.iRecursiveLock unlock];
            }
        };
        recursiveMethod(10);
    });
}

@synchronized是非常简单的一把锁
//使用

- (void)synchronizedTest {
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        static void (^recursiveMethod)(int);
        recursiveMethod = ^(int value){
            if (value > 0) {
                @synchronized(self)
                NSLog(@"%d",value);
                recursiveMethod(value - 1);
            }
        };
        recursiveMethod(10);
    });
}

信号量锁
//一些基本操作

dispatch_semaphore_create(intptr_t value)
//创建信号量，并且创建的时候需要指定信号量的大小

dispatch_semaphore_wait(dispatch_semaphore_t dsema, diapatch_time_t timeout) 
//等待信号量，如果信号量等于0，那么该函数就会一直等待（相当于阻塞当前线程），直到该函数等待的信号量的值大于等于1，该函数会对信号量的值进行减1操作，然后返回

dispatch_semaphore_signal(dispatch_semaphore_t dsema) 
//发送信号量，该函数会对信号量的值进行加1操作

//使用

- (void)lg_dispatch_semaphore_t {
    
    dispatch_semaphore_t sem = dispatch_semaphore_create(0);
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        NSLog(@"任务1");
        dispatch_semaphore_signal(sem);
    });
    
    dispatch_semaphore_wait(sem, DISPATCH_TIME_FOREVER);
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        NSLog(@"任务2");
        dispatch_semaphore_signal(sem);
    });
    dispatch_semaphore_wait(sem, DISPATCH_TIME_FOREVER);
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        NSLog(@"任务3");
    });
}

pthread_mutex是C语言实现的锁，需要开发人员自己实现锁生命周期的管理
//一些基本操作

pthread_mutex_init(pthread_mutex_t mutex,const pthread_mutexattr_t attr)
//初始化锁，pthread_mutexattr_t可用来设置锁的类型

pthread_mutex_lock(pthread_mutex_t mutex)
//加锁

pthread_mutex_trylock(*pthread_mutex_t *mutex)
//加锁，但是上面方法不一样的是当锁已经在使用的时候，返回为EBUSY，而不是挂起等待，成功返回0.失败返回错误信息

pthread_mutex_unlock(pthread_mutex_t *mutex)
//释放锁

pthread_mutex_destroy(pthread_mutex_t* mutex)
//使用完锁之后释放锁

pthread_mutexattr_setpshared()
//设置互斥锁的范围

pthread_mutexattr_getpshared()
//获取互斥锁的范围

//使用

- (void)lg_pthread_mutex {
    
    //非递归
    pthread_mutex_t lock0;
    pthread_mutex_init(&lock0, NULL);
    pthread_mutex_lock(&lock0);
    pthread_mutex_unlock(&lock0);
    pthread_mutex_destroy(&lock0);
    
    //递归
    pthread_mutex_t lock;
    pthread_mutexattr_t attr;
    pthread_mutexattr_init(&attr);
    pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
    pthread_mutex_init(&lock, &attr);
    pthread_mutexattr_destroy(&attr);
    pthread_mutex_lock(&lock);
    pthread_mutex_unlock(&lock);
    pthread_mutex_destroy(&lock);
}

//多读单写，读写互斥

@property (nonatomic ,strong) dispatch_queue_t iQueue;
self.iQueue = dispatch_queue_create("lg", DISPATCH_QUEUE_CONCURRENT);

- (NSString *)lg_read {
    // 异步读取
    __block NSString *ret;
   
    dispatch_sync(self.iQueue, ^{
        // 读取的代码
        ret = self.dataDic[@"name"];
    });
    NSLog(@"%@",ret);
    return ret;
}
-(void)multiRead{
//    多读可以用for循环
    for(int i = 0 ; i < 10 ;i++){
        dispatch_async(self.iQueue, ^{
            // 读取的代码
            [self lg_read];
        });
    }
}

- (void)lg_write: (NSString *)name {
    // 写操作
    //栅栏函数保证了读写互斥
    dispatch_barrier_async(self.iQueue, ^{
        [self.dataDic setObject:name forKey:@"name"];
    });
}