iOS 开发中的八种锁

1、OSSpinLock 自旋锁

需导入头文件:

#import 

__block OSSpinLock oslock = OS_SPINLOCK_INIT;
//线程1
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    NSLog(@"线程1 准备上锁");
    OSSpinLockLock(&oslock);
    sleep(4);
    NSLog(@"线程1");
    OSSpinLockUnlock(&oslock);
    NSLog(@"线程1 解锁成功");
    NSLog(@"----------------------------");
});

//线程2
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    NSLog(@"线程2 准备上锁");
    OSSpinLockLock(&oslock);
    NSLog(@"线程2");
    OSSpinLockUnlock(&oslock);
    NSLog(@"线程2 解锁成功");
});

运行结果：

2017-04-18 10:09:56.437 Dis[993:24124] 线程1 准备上锁
2017-04-18 10:09:56.437 Dis[993:24121] 线程2 准备上锁
2017-04-18 10:10:00.443 Dis[993:24124] 线程1
2017-04-18 10:10:00.444 Dis[993:24124] 线程1 解锁成功
2017-04-18 10:10:00.444 Dis[993:24124] ----------------------------
2017-04-18 10:10:00.502 Dis[993:24121] 线程2
2017-04-18 10:10:00.502 Dis[993:24121] 线程2 解锁成功

当我们锁住线程1时，在同时锁住线程2的情况下，线程2会一直等待（自旋锁不会让等待的进入睡眠状态），直到线程1的任务执行完且解锁完毕，线程2会立即执行。

OS_SPINLOCK_INIT： 默认值为 0,在 locked 状态时就会大于 0，unlocked状态下为 0
OSSpinLockLock(&oslock)：上锁，参数为 OSSpinLock 地址
OSSpinLockUnlock(&oslock)：解锁，参数为 OSSpinLock 地址
OSSpinLockTry(&oslock)：尝试加锁，可以加锁则立即加锁并返回 YES,反之返回 NO

这里顺便提一下trylock和lock使用场景：

当前线程锁失败，也可以继续其它任务，用 trylock 合适
当前线程只有锁成功后，才会做一些有意义的工作，那就 lock，没必要轮询 trylock

2、dispatch_semaphore 信号量锁

dispatch_semaphore_t signal = dispatch_semaphore_create(1); //传入值必须 >=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), ^{
    NSLog(@"线程1 等待ing");
    dispatch_semaphore_wait(signal, overTime); //signal 值 -1
    NSLog(@"线程1");
    dispatch_semaphore_signal(signal); //signal 值 +1
    NSLog(@"线程1 发送信号");
    NSLog(@"-------------------------");
});

//线程2
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    NSLog(@"线程2 等待ing");
    dispatch_semaphore_wait(signal, overTime);
    NSLog(@"线程2");
    dispatch_semaphore_signal(signal);
    NSLog(@"线程2 发送信号");
});

● dispatch_semaphore_create(1)： 传入值必须 >=0, 若传入为 0 则阻塞线程并等待timeout,时间到后会执行其后的语句
● dispatch_semaphore_wait(signal, overTime)：可以理解为 lock,会使得 signal 值 -1
● dispatch_semaphore_signal(signal)：可以理解为 unlock,会使得 signal 值 +1

运行结果：

2017-04-18 13:33:58.317 Dis[1436:72088] 线程2 等待ing
2017-04-18 13:33:58.317 Dis[1436:72085] 线程1 等待ing
2017-04-18 13:33:58.317 Dis[1436:72088] 线程2
2017-04-18 13:33:58.317 Dis[1436:72088] 线程2 发送信号
2017-04-18 13:33:58.317 Dis[1436:72085] 线程1
2017-04-18 13:33:58.318 Dis[1436:72085] 线程1 发送信号
2017-04-18 13:33:58.318 Dis[1436:72085] -------------------------

3、pthread_mutex 互斥锁

使用需导入头文件：

#import 

static pthread_mutex_t pLock;
pthread_mutex_init(&pLock, NULL);
 //1.线程1
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    NSLog(@"线程1 准备上锁");
    pthread_mutex_lock(&pLock);
    sleep(3);
    NSLog(@"线程1");
    pthread_mutex_unlock(&pLock);
});

//1.线程2
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    NSLog(@"线程2 准备上锁");
    pthread_mutex_lock(&pLock);
    NSLog(@"线程2");
    pthread_mutex_unlock(&pLock);
});

运行结果：

2017-04-18 13:44:59.874 Dis[1480:75677] 线程2 准备上锁
2017-04-18 13:44:59.874 Dis[1480:75664] 线程1 准备上锁
2017-04-18 13:44:59.874 Dis[1480:75677] 线程2
2017-04-18 13:45:02.877 Dis[1480:75664] 线程1

● pthread_mutex 中也有个pthread_mutex_trylock(&pLock)，和上面提到的 OSSpinLockTry(&oslock)区别在于，前者可以加锁时返回的是 0，否则返回一个错误提示码；后者返回的 YES和NO
4、NSLock 对象锁
--

NSLock *lock = [NSLock new];
//线程1
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        NSLog(@"线程1 尝试加锁ing...");
        [lock lock];
        sleep(3);//睡眠3秒
        NSLog(@"线程1");
        [lock unlock];
        NSLog(@"线程1解锁成功");
    });
    
//线程2
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        NSLog(@"线程2 尝试加锁ing...");
        BOOL x =  [lock lockBeforeDate:[NSDate dateWithTimeIntervalSinceNow:4]];
        if (x) {
            NSLog(@"线程2");
            [lock unlock];
            NSLog(@"线程2解锁成功");
        }else{
            NSLog(@"失败");
        }
    });

运行结果：

2017-04-18 10:33:45.116 Dis[1057:31500] 线程1 尝试加锁ing...
2017-04-18 10:33:45.116 Dis[1057:31517] 线程2 尝试加锁ing...
2017-04-18 10:33:48.119 Dis[1057:31500] 线程1
2017-04-18 10:33:48.119 Dis[1057:31500] 线程1解锁成功
2017-04-18 10:33:48.119 Dis[1057:31517] 线程2
2017-04-18 10:33:48.120 Dis[1057:31517] 线程2解锁成功

5、NSCondition

● 等待2秒

NSCondition *cLock = [NSCondition new];
//线程1
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    NSLog(@"start");
    [cLock lock];
    [cLock waitUntilDate:[NSDate dateWithTimeIntervalSinceNow:2]];
    NSLog(@"线程1");
    [cLock unlock];
});

运行结果：

2017-04-18 13:15:22.879 Dis[1279:63145] start
2017-04-18 13:15:24.884 Dis[1279:63145] 线程1

● 唤醒一个等待线程

NSCondition *cLock = [NSCondition new];
//线程1
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    [cLock lock];
    NSLog(@"线程1加锁成功");
    [cLock wait];
    NSLog(@"线程1");
    [cLock unlock];
});

//线程2
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    [cLock lock];
    NSLog(@"线程2加锁成功");
    [cLock wait];
    NSLog(@"线程2");
    [cLock unlock];
});

dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    sleep(2);
    NSLog(@"唤醒一个等待的线程");
    [cLock signal];
});

运行结果：

2017-04-18 13:16:16.456 Dis[1297:63832] 线程1加锁成功
2017-04-18 13:16:16.456 Dis[1297:63816] 线程2加锁成功
2017-04-18 13:16:18.456 Dis[1297:63814] 唤醒一个等待的线程
2017-04-18 13:16:18.456 Dis[1297:63832] 线程1

● 唤醒所有等待的线程

.........    
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    sleep(2);
    NSLog(@"唤醒所有等待的线程");
    [cLock broadcast];
});

运行结果：

2017-04-18 13:18:47.376 Dis[1318:65274] 线程1加锁成功
2017-04-18 13:18:47.377 Dis[1318:65272] 线程2加锁成功
2017-04-18 13:18:49.381 Dis[1318:65303] 唤醒所有等待的线程
2017-04-18 13:18:49.381 Dis[1318:65274] 线程1
2017-04-18 13:18:49.382 Dis[1318:65272] 线程2

6、NSRecursiveLock 递归锁

递归锁可以被同一线程多次请求，而不会引起死锁。这主要是用在循环或递归操作中。

NSRecursiveLock *rLock = [NSRecursiveLock new];
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    static void (^RecursiveBlock)(int);
    RecursiveBlock = ^(int value) {
        [rLock lock];
        if (value > 0) {
            NSLog(@"线程%d", value);
            RecursiveBlock(value - 1);
        }
        [rLock unlock];
    };
    RecursiveBlock(4);
});

运行结果：

2017-04-18 10:54:00.226 Dis[1104:37463] 线程4
2017-04-18 10:54:00.226 Dis[1104:37463] 线程3
2017-04-18 10:54:00.226 Dis[1104:37463] 线程2
2017-04-18 10:54:00.226 Dis[1104:37463] 线程1

7、@synchronized 关键字锁

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

运行结果：

2017-04-18 10:57:27.787 Dis[1126:38994] 线程1
2017-04-18 10:57:27.787 Dis[1126:39008] 线程2

8、NSConditionLock 条件锁

相比于 NSLock 多了个 condition 参数，我们可以理解为一个条件标示。

NSConditionLock *cLock = [[NSConditionLock alloc] initWithCondition:0];

//线程1
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    if([cLock tryLockWhenCondition:0]){
        NSLog(@"线程1");
       [cLock unlockWithCondition:1];
    }else{
         NSLog(@"失败");
    }
});

//线程2
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    [cLock lockWhenCondition:3];
    NSLog(@"线程2");
    [cLock unlockWithCondition:2];
});

//线程3
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    [cLock lockWhenCondition:1];
    NSLog(@"线程3");
    [cLock unlockWithCondition:3];
});

运行结果：

2017-04-18 13:06:33.774 Dis[1256:60381] 线程1
2017-04-18 13:06:33.774 Dis[1256:60380] 线程3
2017-04-18 13:06:33.774 Dis[1256:60367] 线程2

● 在初始化 NSConditionLock 对象时，给了他的标示为 0；
● 执行 tryLockWhenCondition:时，我们传入的条件标示也是 0,所 以线程1 加锁成功；
● 执行 unlockWithCondition:时，这时候会把condition由 0 修改为 1，因为condition 修改为了 1， 会先走到 线程3，然后 线程3 又将 condition 修改为 3。