iOS-几种Lock的介绍

lock是什么？我们在使用多线程的时候，可能会遇到多个线程访问同一块资源，这样就很容易引发数据错乱喝数据安全等问题，这时我们就需要保证每次只有一个线程访问一块资源，lock就出来啦。

1、OSSpinLock 自旋锁

应用如下：

__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 解锁成功");

});

运行结果

从图中可以看到，当我们锁住线程1时，在同时锁住线程2的情况下，线程2会一直等待（自旋锁不会让等待进入睡眠状态），知道线程1的认为执行完毕，线程2会立即执行；

修改一下，注释掉线程1中的解锁代码。

//OSSpinLockUnlock(&oslock);

注释掉解锁代码之后

我们看到注释之后，程序绕过线程1，直接调用了线程2的解锁方法，才会继续执行线程1的任务，同一个锁对象。正常情况下lock与unlock是成对出现的。

线程加锁也会用失败的可能，有时候也会考虑这种情况。这时候OSSpinLockTry（）方法就比较合适，如果允许线程枷锁失败，也可以继续其他任务，可以用tryLock。如果只有线程枷锁成功才会做一些有意义的工作，那就lock。

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变成0

NSLog(@"线程1");

dispatch_semaphore_signal(signal); //signal 值 +1，变成1，执行线程1.

NSLog(@"线程1 发送信号");

NSLog(@"--------------------------------------------------------");

});

运行结果，signal大于0

初始信号量大于0，所以没有阻塞线程，直接执行了线程1，线程2.把初始信号量改为0.

dispatch_semaphore_t signal = dispatch_semaphore_create(0);

这时候overtime生效了

3、pthread_mutex互斥锁

在<<不再安全的的OSSpinlock>>中提到性能最好的OSSpinLock已经不再线程安全，换成了，pthread_mutex.

例子：

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);

});

互斥锁的运行结果

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

经过上面几种例子，我们可以发现：加锁后只能有一个线程访问该对象，后面的线程需要排队，并且 lock 和 unlock 是对应出现的，同一线程多次 lock 是不允许的，而递归锁允许同一个线程在未释放其拥有的锁时反复对该锁进行加锁操作

static pthread_mutex_t pLock;

pthread_mutexattr_t attr;

pthread_mutexattr_init(&attr); //初始化attr并且给它赋予默认

pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE); //设置锁类型，这边是设置为递归锁

pthread_mutex_init(&pLock, &attr);

pthread_mutexattr_destroy(&attr); //销毁一个属性对象，在重新进行初始化之前该结构不能重新使用

//1.线程1

dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{

static void (^RecursiveBlock)(int);

RecursiveBlock = ^(int value) {

pthread_mutex_lock(&pLock);

if (value > 0) {

NSLog(@"value: %d", value);

RecursiveBlock(value - 1);

}

pthread_mutex_unlock(&pLock);

};

RecursiveBlock(5);

});

递归锁的运行结果

上面的代码如果我们用 pthread_mutex_init(&pLock, NULL) 初始化会出现死锁的情况，递归锁能很好的避免这种情况的死锁；

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);//睡眠5秒

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];

}else{

NSLog(@"失败");

}

});

lock结果

lock lockBeforeDate:

5、NSCondition，信号量。

@interface NSCondition:NSObject{

@private

void *_priv

}

-(void)wait;//进入等待状态

-(void)waitUntilDate:(NSDate *)limit;//让一个线程等待一定时间

-(void)signal;//唤醒一个等待的线程

-(void)broadcast;//唤醒所有等待的线程

@property(nullable,copy)NSString *name;

例子：等待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];

});

唤醒等待的线程

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];

});

唤醒一个线程

[cLock broadcast];//唤醒所有的线程

所有线程都被唤醒执行了

6、@synchronized 条件锁

@synchronized 用法最简单的锁。@synchronized所做的事情和lock类似，它防止不同的线程同时执行同一段代码。但在某些情况下，相比使用NSLock，@synchronized使用更方便，可读性更高。

下面实现一个线程安全的队列：

@implementation ThreadSafeQueue

{

NSMutableArray *_elements;

NSLock *_lock;

}

- (instancetype)init

{

self = [super init];

if (self) {

_elements = [NSMutableArray array];

_lock = [[NSLock alloc] init];

}

return self;

}

- (void)push:(id)element

{

[_lock lock];

[_elements addObject:element];

[_lock unlock];

}

@end

上面的 ThreadSafeQueue 类有个 init 方法，它初始化了一个 _elements 数组和一个 NSLock 实例。这个类还有个 push: 方法，它先获取锁、然后向数组中插入元素、最终释放锁。可能会有许多线程同时调用 push: 方法，但是 [_elements addObject:element] 这行代码在任何时候将只会在一个线程上运行。

我们可以使用@synchronized结构更简要的实现这些：

@implementation ThreadSafeQueue

{

NSMutableArray *_elements;

}

- (instancetype)init

{

self = [super init];

if (self) {

_elements = [NSMutableArray array];

}

return self;

}

- (void)push:(id)element

{

@synchronized (self) {

[_elements addObject:element];

}

}

在前面的例子中，”synchronized block” 与 [_lock lock] 和 [_lock unlock] 效果相同。你可以把它当成是锁住 self，仿佛 self 就是个 NSLock。锁在左括号 { 后面的任何代码运行之前被获取到，在右括号 }。

本文参考：http://blog.csdn.net/qq_30513483/article/details/52349968