28.锁

OSSpinLock

 NSString *phoneVersion  = [UIDevice currentDevice].systemVersion;
    if (phoneVersion.floatValue >= 10.0) {
        
        // 线程1
        
        __block os_unfair_lock lock = OS_UNFAIR_LOCK_INIT;
        
        dispatch_async(dispatch_get_main_queue(), ^{
           
            NSLog(@"准备上锁1");
            
            if (os_unfair_lock_trylock(&lock)) { // 尝试加锁 可以加锁则立即加锁并返回YES,反之返回NO
                
//                这里顺便提一下trylock和lock使用场景:
//                当前线程锁失败,也可以继续其它任务,用 trylock 合适
//                当前线程只有锁成功后,才会做一些有意义的工作,那就 lock,没必要轮询 trylock
            }
            
            os_unfair_lock_lock(&lock);     // 加锁
            
            os_unfair_lock_unlock(&lock);   // 解锁
        });
        
    }else {
        
        // 线程1
        
        __block OSSpinLock lock = OS_SPINLOCK_INIT;
        
        dispatch_async(dispatch_get_main_queue(), ^{
            
            NSLog(@"准备上锁1");
            
            if (OSSpinLockTry(&lock)) { // 尝试加锁
                
//                这里顺便提一下trylock和lock使用场景:
//                当前线程锁失败,也可以继续其它任务,用 trylock 合适
//                当前线程只有锁成功后,才会做一些有意义的工作,那就 lock,没必要轮询 trylock
            }
            
            OSSpinLockLock(&lock);      // 加锁
            
            OSSpinLockUnlock(&lock);    // 解锁
            
        });
    }
  • 如果一个低优先级的线程获得锁并访问共享资源,这时一个高优先级的线程也尝试获得这个锁,它会处于 spin lock 的忙等状态从而占用大量 CPU。此时低优先级线程无法与高优先级线程争夺CPU 时间,从而导致任务迟迟完不成、无法释放lock。这并不只是理论上的问题,libobjc 已经遇到了很多次这个问题了,于是苹果的工程师停用了OSSpinLock

dispatch_semaphore_t 信号量

dispatch_semaphore_t semaphore = dispatch_semaphore_create(10); // 传入的值必须大于等于0,若传入0则阻塞线程并等待timeout,时间到后会执行其后的语句
    
    dispatch_time_t overTime    = dispatch_time(DISPATCH_TIME_NOW, 3.0f * NSEC_PER_SEC);
    
    // 线程1
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
       
        dispatch_semaphore_wait(semaphore, overTime); // signal值 +1
        
        NSLog(@"执行耗时操作");
        
        dispatch_semaphore_signal(semaphore); // signal值 -1
        
    });

关于信号量,我们可以用停车来比喻:

  • 停车场剩余4个车位,那么即使同时来了四辆车也能停的下。如果此时来了五辆车,那么就有一辆需要等待。
  • 信号量的值(signal)就相当于剩余车位的数目,dispatch_semaphore_wait 函数就相当于来了一辆车,dispatch_semaphore_signal 就相当于走了一辆车。停车位的剩余数目在初始化的时候就已经指明了(dispatch_semaphore_create(long value)),调用一次 dispatch_semaphore_signal,剩余的车位就增加一个;调用一次dispatch_semaphore_wait 剩余车位就减少一个;当剩余车位为 0 时,再来车(即调用 dispatch_semaphore_wait)就只能等待。有可能同时有几辆车等待一个停车位。有些车主没有耐心,给自己设定了一段等待时间,这段时间内等不到停车位就走了,如果等到了就开进去停车。而有些车主就像把车停在这,所以就一直等下去。

pthread_mutex 互斥锁 需要引入头文件

 static pthread_mutex_t pLock;
    
    pthread_mutex_init(&pLock, NULL);
    
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
       
        pthread_mutex_lock(&pLock); // 加锁
        
        sleep(3); // 模拟耗时
        
        pthread_mutex_unlock(&pLock); // 解锁
    });

pthread_mutex(recursive) 递归锁

 static pthread_mutex_t pLock2;
    
    pthread_mutexattr_t attr;
    
    pthread_mutexattr_init(&attr); // 初始化attr并且给它赋予默认
    
    pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE); // 设置锁类型,这边是设置为递归锁
    
    pthread_mutex_init(&pLock2, &attr);
    
    pthread_mutexattr_destroy(&attr); // 销毁一个属性对象,在重新进行初始化之前该结构不能重新使用
    
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
       
        static void (^RecursiveBlock)(int);
        
        RecursiveBlock  = ^(int value) {
            
            pthread_mutex_lock(&pLock2);
            
            if (value > 0) {
                
                NSLog(@"value : %d",value);
                
                RecursiveBlock(value - 1);
            }
            
            pthread_mutex_unlock(&pLock2);
        };
        
        RecursiveBlock(5);
    });

NSLock 普通锁

NSLock *lock    = [[NSLock alloc] init];
    
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        
        [lock lock]; // 加锁
        
        
        [lock unlock]; // 解锁
    });
    
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
       
        // 尝试加速
        BOOL x  = [lock lockBeforeDate:[NSDate dateWithTimeIntervalSinceNow:4]];
        
        if (x) {
            
            [lock unlock];
        }else {
            
            NSLog(@"失败");
        }
    });

NSCondition

NSCondition *cLock  = [[NSCondition alloc] init];
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
       
        [cLock lock];  // 加锁
        
        [cLock waitUntilDate:[NSDate dateWithTimeIntervalSinceNow:2]];  // 线程等待两秒
        
        [cLock wait];   // 线程等待
        
        [cLock signal]; // 唤醒一个等待的线程
        
        [cLock broadcast]; // 唤醒所有等待的线程
        
        [cLock unlock]; // 解锁
    });

NSRecursiveLock 递归锁

 NSRecursiveLock *rLock   = [[NSRecursiveLock alloc] init];
    
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
       
        static void(^RecursiveBlock)(int);
        
        RecursiveBlock  = ^(int value){
        
            [rLock tryLock];
            
            if (value > 0) {
                
                RecursiveBlock(value - 1);
            }
            
            [rLock unlock];
        };
        
        RecursiveBlock(4);
    });

@synchronized 条件锁

dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
       
        @synchronized (self) {
            
            sleep(2);
            
            NSLog(@"@synchronized线程");
        }
    });

NSConditionLock 条件锁

NSConditionLock *cLock2  = [[NSConditionLock alloc] init];
    
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
       
        if ([cLock2 tryLockWhenCondition:0]) {
            
            NSLog(@"NSConditionLock线程1");
            [cLock2 unlockWithCondition:1];
        } else {
            
            NSLog(@"失败");
        }
        
    });
    
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    
        if ([cLock2 tryLockWhenCondition:3]) {
            
//            [cLock2 lockWhenCondition:3];
            NSLog(@"NSConditionLock线程2");
            
            [cLock2 unlockWithCondition:2];
        } else {
            
            NSLog(@"失败");
        }
    });
    
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
       
        if ([cLock2 tryLockWhenCondition:1]) {
            
            NSLog(@"NSConditionLock线程3");
            [cLock2 unlockWithCondition:3];
        }
    });
  • 我们在初始化NSConditionLock 对象时,给了他的标示为 0
  • 执行 tryLockWhenCondition:时,我们传入的条件标示也是 0,所 以线程1 加锁成功
  • 执行 unlockWithCondition:时,这时候会把condition由 0 修改为 1
  • 因为condition 修改为了 1, 会先走到 线程3,然后 线程3 又将 condition 修改为 3
  • 最后 走了 线程2 的流程
  • 从上面的结果我们可以发现,NSConditionLock 还可以实现任务之间的依赖。

你可能感兴趣的:(28.锁)