iOS线程锁

2018-02-27 11:14:23来源:https://www.jianshu.com/p/f4c4d01224cc作者:情商为0的程序猿人点击

分享


原子操作

在多线程要操作一个字符串时,为了保证只有一个线程在赋值或者取值的时候我们会考虑加锁。


atomic属性内部的锁称为 自旋锁
凡是线程安全的对象,内部肯定会加锁
@property(atomic,copy)NSString *name;

那么atomic是应该怎么在setter和getter中实现呢,原理是仅需要给self加锁,重写setter,getter:


@synthesize name = _name;
- (void)setName:(NSString *)name {
@synchronized(self) {
_name = [name copy];
}
}
- (NSString *)name {
@synchronized(self) {
return _name;
}
}

不过这么写,也不能保证线程安全。如果线程A调用了getter,同时线程B调用了setter,那么A线程getter得到的值,可能是B在set之前的原始值,也可能是B set的值。同时这个属性的值,也可能是B set的值。
所以,保证数据完整性不能简单靠一把锁来完成,毕竟这个是多线程编程最大的难点。


自旋锁和互斥锁
相同点:
都能保证同一时间只有一个线程访问共享资源。都能保证线程安全。

不同点:
互斥锁:如果共享数据已经有其他线程加锁了,线程会进入休眠状态等待锁。一旦被访问的资源被解锁,则等待资源的线程会被唤醒。
自旋锁:如果共享数据已经有其他线程加锁了,线程会以死循环的方式等待锁,一旦被访问的资源被解锁,则等待资源的线程会立即执行。

自旋锁的效率高于互斥锁。
1.信号量 dispatch_semaphore

YY大神推荐使用信号量dispatch_semaphore作为自旋锁的替代方案。


dispatch_semaphore_t signal = dispatch_semaphore_create(1);
dispatch_time_t timeout = dispatch_time(DISPATCH_TIME_NOW, 5.0f * NSEC_PER_SEC);

//线程1
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
NSLog(@"线程1 holding");
dispatch_semaphore_wait(signal, timeout); //signal 值 -1
NSLog(@"线程1 sleep");
sleep(4);
NSLog(@"线程1");
dispatch_semaphore_signal(signal); //signal 值 +1
NSLog(@"线程1 post singal");
});

//线程2
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
NSLog(@"线程2 holding");
dispatch_semaphore_wait(signal, timeout);
NSLog(@"线程2 sleep");
sleep(4);
NSLog(@"线程2");
dispatch_semaphore_signal(signal);
NSLog(@"线程2 post signal");
});

dispatch_semaphore_create(1)为创建信号,()中数字表示可以同时几个线程使用信号。为1表示同步使用。上述代码如果此处标2就和没设置信号量一样,并发自行运行。如果设置为0,则一律等待overTime时自动释放,所有代码都不执行,理论上也具有同步作用。
dispatch_semaphore_wait中传入的timeout表示最长加锁时间,自动释放锁后,其它线程可以获取信号并继续运行。


2.pthread_mutex锁

pthread表示的是POSIX thread,定义的是一组跨平台线程相关的API。
pthread_mutex互斥锁是一个非递归锁,如果同一线程重复调用加锁会造成死锁。
用法比较简单


static pthread_mutex_t pmutexLock;
pthread_mutex_init(&pLock, NULL);

//1.线程2
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0), ^{
NSLog(@"线程2 befor lock");
pthread_mutex_lock(&pLock);
NSLog(@"线程2");
pthread_mutex_unlock(&pLock);
});

//2.线程1
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
NSLog(@"线程1 before lock");
pthread_mutex_lock(&pLock);
sleep(3);
NSLog(@"线程1");
pthread_mutex_unlock(&pLock);
});

pthread_mutex(recursive) 递归锁,比较安全,同一线程有且仅有一次加锁,重复加锁不会死锁。无论加锁几次,只需解锁一次。


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

};
NSLog(@"线程1 before lock");
RecursiveBlock(5);
NSLog(@"线程1");
pthread_mutex_unlock(&pLock);
NSLog(@"线程1 unlock");
});

//2.线程2
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
NSLog(@"线程2 before lock");
pthread_mutex_lock(&pLock);
NSLog(@"线程2");
pthread_mutex_unlock(&pLock);
NSLog(@"线程2 unlock");
});

3.@synchronized

@synchronized 实际上是把修饰对象当做锁来使用。这是通过一个哈希表来实现的,OC 在底层使用了一个互斥锁的数组(你可以理解为锁池),通过对对象去哈希值来得到对应的互斥锁。


各种锁的性能参考下YY大神的图


image

相同类型的锁递归锁和普通锁效率相差接近一倍,如果不会在循环或者递归中频繁使用加锁和解锁,不建议使用递归锁;从效率上讲,建议用互斥锁pthread_mutex(YYKit方案)或者信号量dispatch_semaphore作为替代。
OSSpinlock各路大神都说有问题,还有iOS的各种锁就不一一细说了,如果想了解更多的线程锁自行去搜索哈。









最新文章

123

最新摄影

闪念基因

微信扫一扫

第七城市微信公众平台