iOS多线程编程中，经常碰到多个线程访问共同的一个资源，在线程相互交互的情况下，需要一些同步措施，来保证线程之间交互的时候是安全的。下面我们一起看一下学一下iOS的几种常用的加锁方式，希望对大家有所帮助！！！
@synchronized
NSLock对象锁
NSRecursiveLock递归锁
NSConditionLock条件锁
dispatch_semaphore 信号量实现加锁（也就是GCD）
OSSpinLock 与 os_unfair_lock
pthread_mutex
介绍与使用
1.@synchronized
@synchronized关键字加锁，互斥锁，性能较差不推荐在项目中使用。
@synchronized(这里添加一个OC对象，一般使用self) {
这里写要加锁的代码
}
注意点
1.加锁的代码要尽量少
2.添加的OC对象必须在多个线程中都是同一个对象
3.它的优点是不需要显式的创建锁对象，便可以实现锁的机制。
- @synchronized块会隐式的添加异常处理例程来保护代码，该处理例程会在异常抛出的时候就会自动 的释放互斥锁。如果不想让隐式的异常处理例程带来额外的开销，你可以考虑使用锁对象。
下面我们以一个最经典的例子：卖票
//设置票的数量为5
_tickets = 5;
//线程1
dispatch_async(self.concurrentQueue, ^{
[self saleTickets];
});
//线程2
dispatch_async(self.concurrentQueue, ^{
[self saleTickets];
});
- (void)saleTickets
{
while (1) {
@synchronized(self) {
[NSThread sleepForTimeInterval:1];
if (_tickets > 0) {
_tickets--;
NSLog(@"剩余票数= %ld, Thread:%@",_tickets,[NSThread currentThread]);
} else {
NSLog(@"票卖完了 Thread:%@",[NSThread currentThread]);
break;
}
}
}
}
2.NSLock
基本所有锁的接口都是通过NSLocking协议定义的，定义了lock和unlock方法，通过这些方法获取和释放锁。NSLock是对mutex普通锁的封装
下面还是以卖票的例子讲述一下。
//设置票的数量为5
_tickets = 5;
//创建锁
_mutexLock = [[NSLock alloc] init];
//线程1
dispatch_async(self.concurrentQueue, ^{
[self saleTickets];
});
//线程2
dispatch_async(self.concurrentQueue, ^{
[self saleTickets];
});
-
(void)saleTickets
{while (1) {
[NSThread sleepForTimeInterval:1];
//加锁
[_mutexLock lock];
if (_tickets > 0) {
_tickets--;
NSLog(@"剩余票数= %ld, Thread:%@",_tickets,[NSThread currentThread]);
} else {
NSLog(@"票卖完了 Thread:%@",[NSThread currentThread]);
break;
}
//解锁
[_mutexLock unlock];
}
}
3.NSRecursiveLock递归锁
使用锁比较容易犯的错误是在递归或者循环中造成死锁。
如下代码锁会被多次lock，造成自己被阻塞。
//创建锁
_mutexLock = [[NSLock alloc]init];
//线程1
dispatch_async(self.concurrentQueue, ^{
static void(^TestMethod)(int);
TestMethod = ^(int value)
{
[_mutexLock lock];
if (value > 0)
{
[NSThread sleepForTimeInterval:1];
TestMethod(value--);
}
[_mutexLock unlock];
};
TestMethod(5);
});
如果把这个NSLock换成NSRecursiveLock，就可以解决问题。
NSRecursiveLock类定义的锁，可以在同一线程多次lock，不会造成死锁。
//创建锁
_rsLock = [[NSRecursiveLock alloc] init];
//线程1
dispatch_async(self.concurrentQueue, ^{
static void(^TestMethod)(int);
TestMethod = ^(int value)
{
[_rsLock lock];
if (value > 0)
{
[NSThread sleepForTimeInterval:1];
TestMethod(value--);
}
[_rsLock unlock];
};
TestMethod(5);
});
4.NSConditionLock条件锁
NSMutableArray *products = [NSMutableArray array];
NSInteger HAS_DATA = 1;
NSInteger NO_DATA = 0;
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
while (1) {
[lock lockWhenCondition:NO_DATA];
[products addObject:[[NSObject alloc] init]];
NSLog(@"produce a product,总量:%zi",products.count);
[lock unlockWithCondition:HAS_DATA];
sleep(1);
}
});
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
while (1) {
NSLog(@"wait for product");
[lock lockWhenCondition:HAS_DATA];
[products removeObjectAtIndex:0];
NSLog(@"custome a product");
[lock unlockWithCondition:NO_DATA];
}
});
在线程1中的加锁使用了lock，所以是不要条件的，也就锁住了。但在unlock的使用整型条件，它可以开启其他线程中正在等待钥匙的临界池，当线程1循环到一次的时候，打开了线程2的阻塞。
NSCoditionLock中lock,lockWhenCondition:与unlock，unlockWithCondition:是可以随意组合的，具体使用根据需求来区分。
NSCoditionLock 是对NSCodition的进一步封装，可以设置具体的条件值，而NSCodition是对mutex和cond的封装---看本篇博客7.3 条件锁
5.dispatch_semaphore信号量实现加锁
dispatch_semaphore_t signal = dispatch_semaphore_create(1);
dispatch_time_t overTime = dispatch_time(DISPATCH_TIME_NOW, 3 * NSEC_PER_SEC);
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
dispatch_semaphore_wait(signal, overTime);
NSLog(@"需要线程同步的操作1 开始");
sleep(2);
NSLog(@"需要线程同步的操作1 结束");
dispatch_semaphore_signal(signal);
});
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
sleep(1);
dispatch_semaphore_wait(signal, overTime);
NSLog(@"需要线程同步的操作2");
dispatch_semaphore_signal(signal);
});
dispatch_semaphore是GCD用于同步的方式，与之相关的共有三个函数，dispatch_semaphore_wait，dispatch_semaphore_signal，dispatch_semaphore_create。
（1）dispatch_semaphore_create的声明为：
dispatch_semaphore_t dispatch_semaphore_create(long value);
传入的参数是long类型，输出一个dispatch_semaphore_t类型值为Value的信号量（value传入值不能小于0，否则会报错NULL）
（2）dispatch_semaphore_signal声明为下面：
long dispatch_semaphore_signal(dispatch_semaphore_t dsema);
这个方法会使dsema加1；
（3）dispatch_semaphore_wait的声明为下面：
long dispatch_semaphore_wait(dispatch_semaphore_t dsema, dispatch_time_t timeout);
这个方法会使dsema减1。
整个逻辑如下：
如果dsema信号量值为大于0，该函数所在线程就会继续执行下面的语句，并将信号量的减去1；如果dsema为0时，函数就会阻塞当前的线程，如果等待的期间发现dsema的值被dispatch_semaphore_signal加1了，并且该函数得到了信号量，那么继续向下执行，并将信号量减1，如果等待期间没有获得信号量或者值一直为0，那么等到timeout，所处的线程也会自动执行下面的代码。
dispatch_semaphore，当信号量为1时，可以作为锁使用。如果没有出现等待的情况，它的性能比pthread_mutex还要高，当如果有等待情况的时候，性能就会下降很多，相比OSSpinLock（暂不讲解），它的优势在于等待的时侯不会消耗CPU资源。
针对上面代码，发现如果超时时间overTime>2,可完成同步操作，反之，在线程1还没有执行完的情况下，此时超时了，将自动执行下面的代码。
上面代码执行结果：
2018-09-18 15:40:52.324 SafeMultiThread[35945:579032] 需要线程同步的操作1 开始
2018-09-18 15:40:52.325 SafeMultiThread[35945:579032] 需要线程同步的操作1 结束
2018-09-18 15:40:52.326 SafeMultiThread[35945:579033] 需要线程同步的操作2
如果将overTime<2s的时候，执行为
2018-09-18 15:40:52.049 SafeMultiThread[30834:434334] 需要线程同步的操作1 开始
2018-09-18 15:40:52.554 SafeMultiThread[30834:434332] 需要线程同步的操作2
2018-09-18 15:40:52.054 SafeMultiThread[30834:434334] 需要线程同步的操作1 结束
6.OSSpinLock自旋锁与os_unfair_lock
6.1 OSSpinLock
OSSpinLock叫做“自旋锁”，自旋锁的线程会处于忙等（busy-wait）状态，一直占用着CPU资源
但是目前是不再安全了，在iOS 10之后弃用啦，如果等待锁的线程优先级较高，它会一直占用着CPU资源，优先级低的线程就无法释放锁。
在使用的过程中需要导入头文件#import <libkern/OSAtomic.h>
//初始化
OSSpinLock lock = OS_SPINLOCK_INIT;
//尝试加锁（如果需要等待就不加锁，直接返回false；如果不需要等待就加锁，返回True）
bool result = OSSpinLockTry(&lock);
//加锁
OSSpinLockLock(&lock);
//解锁
OSSpinLockUnlock(&lock)
6.2 os_unfair_lock互斥锁
os_unfair_lock用于取代不安全的OSSpinLock，从iOS10开始才支持。从底层调用看，等待os_unfair_lock锁的线程会处于休眠状态，并非忙等
os_unfair_lock需要导入头文件#import<os/lock.h>
//初始化
os_unfair_lock lock = OS_UNFAIR_LOCK_INIT;
//尝试加锁
os_unfair_lock_trylock(&lock);
//加锁
os_unfair_lock_lock(&lock);
//解锁
os_unfair_lock_unlock(&lock);
7.pthread_mutex
mutex叫做“互斥锁”，等待锁的线程处于休眠状态
需要导入头文件#import <pthread.h>
7.1
//初始化锁的属性
pthread_mutexattr_t attr;
pthread_mutexattr_init(&attr);
pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_NORMAL);
//初始化锁
pthread_mutex_t mutex;
pthread_mutex_init(&mutex, &attr);
//尝试加锁
pthread_mutex_trylock(&mutex);
//加锁
pthread_mutex_lock(&mutex);
//解锁
pthread_mutex_unlock(&mutex);
//销毁相关资源 --pthread_mutex在对象类释放的时候要销毁，其他锁无此情况
pthread_mutexattr_destroy(&attr);
pthread_mutex_destroy(&mutex);
7.2 pthread_mutex-递归锁
//初始化锁的属性
pthread_mutexattr_t attr;
pthread_mutexattr_t_int(&attr);
pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);//递归锁
//初始化锁
pthread_mutex_t mutex;
pthread_mutex_init(&mutex, &attr);
7.3 pthread_mutex-条件
import "MutexDemo3.h"
import <pthread.h>
@interface MutexDemo3()
@property (assign, nonatomic) pthread_mutex_t mutex;
@property (assign, nonatomic) pthread_cond_t cond;
@property (strong, nonatomic) NSMutableArray *data;
@end
@implementation MutexDemo3
-
(instancetype)init
{
if (self = [super init]) {
// 初始化属性
pthread_mutexattr_t attr;
pthread_mutexattr_init(&attr);
pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
// 初始化锁
pthread_mutex_init(&_mutex, &attr);
// 销毁属性
pthread_mutexattr_destroy(&attr);// 初始化条件 pthread_cond_init(&_cond, NULL); self.data = [NSMutableArray array];}
return self;
} -
(void)otherTest
{
[[[NSThread alloc] initWithTarget:self selector:@selector(__remove) object:nil] start];[[[NSThread alloc] initWithTarget:self selector:@selector(__add) object:nil] start];
}
// 生产者-消费者模式
// 线程1
// 删除数组中的元素
-
(void)__remove
{
pthread_mutex_lock(&_mutex);
NSLog(@"__remove - begin");if (self.data.count == 0) {
// 等待
pthread_cond_wait(&_cond, &_mutex);
}[self.data removeLastObject];
NSLog(@"删除了元素");pthread_mutex_unlock(&_mutex);
}
// 线程2
// 往数组中添加元素
-
(void)__add
{
pthread_mutex_lock(&_mutex);sleep(1);
[self.data addObject:@"Test"];
NSLog(@"添加了元素");// 信号
pthread_cond_signal(&_cond);
// 广播
// pthread_cond_broadcast(&_cond);pthread_mutex_unlock(&_mutex);
} -
(void)dealloc
{
pthread_mutex_destroy(&_mutex);
pthread_cond_destroy(&_cond);
}
@end
网友评论