内存使用情况(感谢ibireme)
image.png
线程不安全的示例
可以开出访问出现数据泄露的情况
//并发+异步
dispatch_queue_t queue = dispatch_queue_create("lock", DISPATCH_QUEUE_CONCURRENT);
for (NSInteger i = 0 ; i < 10; i++ ) {
dispatch_async(queue, ^{
[self sellTicket];
});
}
/**
卖票操作
*/
-(void)sellTicket{
if (self.restTicket > 0) {
NSLog(@"卖出去了一张票");
self.restTicket -- ;
}
NSLog(@"当前剩余票数 %lu",self.restTicket);
}
///打印的结果
//2019-05-20 23:24:27.551421+0800 iOS线程锁[10862:337839] 卖出去了一张票
//2019-05-20 23:24:27.551421+0800 iOS线程锁[10862:337838] 卖出去了一张票
//2019-05-20 23:24:27.551421+0800 iOS线程锁[10862:337855] 卖出去了一张票
//2019-05-20 23:24:27.551454+0800 iOS线程锁[10862:337841] 卖出去了一张票
//2019-05-20 23:24:27.551611+0800 iOS线程锁[10862:337839] 当前剩余票数 4
//2019-05-20 23:24:27.551640+0800 iOS线程锁[10862:337855] 当前剩余票数 4
//2019-05-20 23:24:27.551630+0800 iOS线程锁[10862:337841] 当前剩余票数 3
//2019-05-20 23:24:27.551651+0800 iOS线程锁[10862:337838] 当前剩余票数 2
//2019-05-20 23:24:27.551738+0800 iOS线程锁[10862:337839] 卖出去了一张票
//2019-05-20 23:24:27.551776+0800 iOS线程锁[10862:337855] 卖出去了一张票
//2019-05-20 23:24:27.551786+0800 iOS线程锁[10862:337841] 卖出去了一张票
//2019-05-20 23:24:27.552064+0800 iOS线程锁[10862:337838] 卖出去了一张票
//2019-05-20 23:24:27.552215+0800 iOS线程锁[10862:337840] 卖出去了一张票
//2019-05-20 23:24:27.552275+0800 iOS线程锁[10862:337857] 卖出去了一张票
//2019-05-20 23:24:27.552328+0800 iOS线程锁[10862:337839] 当前剩余票数 1
//2019-05-20 23:24:27.553672+0800 iOS线程锁[10862:337838] 当前剩余票数 0
//2019-05-20 23:24:27.553789+0800 iOS线程锁[10862:337841] 当前剩余票数 18446744073709551615
//2019-05-20 23:24:27.553822+0800 iOS线程锁[10862:337855] 当前剩余票数 18446744073709551614
//2019-05-20 23:24:27.553841+0800 iOS线程锁[10862:337840] 当前剩余票数 18446744073709551613
//2019-05-20 23:24:27.554254+0800 iOS线程锁[10862:337857] 当前剩余票数 18446744073709551612
一、线程锁示例
1.OSSpinLock （自旋锁）
可以明显开出 OSSpinLock 已经不再安全
__block OSSpinLock spinlock = OS_SPINLOCK_INIT;
//并发+异步
dispatch_queue_t queue = dispatch_queue_create("lock", DISPATCH_QUEUE_CONCURRENT);
for (NSInteger i = 0 ; i < 10; i++ ) {
dispatch_async(queue, ^{
OSSpinLockLock(&spinlock);
[self sellTicket];
OSSpinLockUnlock(&spinlock);
});
}
2.os_unfair_lock 互斥锁
__block os_unfair_lock unfairlock = OS_UNFAIR_LOCK_INIT;
//并发+异步
dispatch_queue_t queue = dispatch_queue_create("lock", DISPATCH_QUEUE_CONCURRENT);
for (NSInteger i = 0 ; i < 10; i++ ) {
dispatch_async(queue, ^{
os_unfair_lock_lock(&unfairlock);
[self sellTicket];
os_unfair_lock_unlock(&unfairlock);
});
}
3.pthread_mutex_t 互斥锁
__block pthread_mutex_t mutex_t;
pthread_mutex_init(&mutex_t, NULL);
//并发+异步
dispatch_queue_t queue = dispatch_queue_create("lock", DISPATCH_QUEUE_CONCURRENT);
for (NSInteger i = 0 ; i < 10; i++ ) {
dispatch_async(queue, ^{
pthread_mutex_lock(&mutex_t);
[self sellTicket];
pthread_mutex_unlock(&mutex_t);
});
}
4.dispatch_semaphore_t 信号量
dispatch_semaphore_t semaphore = dispatch_semaphore_create(1);
//并发+异步
dispatch_queue_t queue = dispatch_queue_create("lock", DISPATCH_QUEUE_CONCURRENT);
for (NSInteger i = 0 ; i < 10; i++ ) {
dispatch_async(queue, ^{
dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
[self sellTicket];
dispatch_semaphore_signal(semaphore);
});
}
5.NSLock 互斥锁 对象锁
__block NSLock *lock = [[NSLock alloc]init];
//并发+异步
dispatch_queue_t queue = dispatch_queue_create("lock", DISPATCH_QUEUE_CONCURRENT);
for (NSInteger i = 0 ; i < 10; i++ ) {
dispatch_async(queue, ^{
[lock lock];
[self sellTicket];
[lock unlock];
});
}
6.NSCondition 条件锁 对象锁
__block NSCondition *lock = [[NSCondition alloc]init];
//并发+异步
dispatch_queue_t queue = dispatch_queue_create("lock", DISPATCH_QUEUE_CONCURRENT);
for (NSInteger i = 0 ; i < 10; i++ ) {
dispatch_async(queue, ^{
[lock lock];
[self sellTicket];
[lock unlock];
});
}
///让线程等待
[lock wait];
///让线程等待一定的时间
[lock waitUntilDate:nil];
///唤醒线程
[lock signal];
///唤醒所有线程
[lock broadcast];
7.NSConditionLock 条件锁 对象锁
__block NSConditionLock *lock = [[NSConditionLock alloc]init];
//并发+异步
dispatch_queue_t queue = dispatch_queue_create("lock", DISPATCH_QUEUE_CONCURRENT);
for (NSInteger i = 0 ; i < 10; i++ ) {
dispatch_async(queue, ^{
[lock lock];
[self sellTicket];
[lock unlock];
});
}
8.NSRecursiveLock 递归锁
可以不必解锁就可以再次使用 多用于循环或者递归操作
__block NSRecursiveLock *lock = [[NSRecursiveLock alloc]init];
//并发+异步
dispatch_queue_t queue = dispatch_queue_create("lock", DISPATCH_QUEUE_CONCURRENT);
for (NSInteger i = 0 ; i < 10; i++ ) {
dispatch_async(queue, ^{
[lock lock];
[self sellTicket];
[lock unlock];
});
}
9.@synchronized 递归锁
//并发+异步
dispatch_queue_t queue = dispatch_queue_create("lock", DISPATCH_QUEUE_CONCURRENT);
for (NSInteger i = 0 ; i < 10; i++ ) {
dispatch_async(queue, ^{
@synchronized (self) {
[self sellTicket];
}
});
}
10.pthread_mutexattr_t attr
// 初始化
pthread_mutex_t mutex_t;
pthread_mutexattr_t attr;
pthread_mutexattr_init(&attr); //初始化attr并且给它赋予默认pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE); //设置锁类型，这边是设置为递归锁
pthread_mutex_init(&mutex_t, &attr);
pthread_mutexattr_destroy(&attr); //销毁一个属性对象，在重新进行初始化之前该结构不能重新使用
// 加锁
pthread_mutex_lock(&mutex_t);
// 解锁
pthread_mutex_unlock(&mutex_t);
/*
注: 递归锁可以被同一线程多次请求，而不会引起死锁。
即在同一线程中在未解锁之前还可以上锁, 执行锁中的代码。
这主要是用在循环或递归操作中。
*/
二、锁的注解
1、自旋锁
OSSpinLock 就是典型的自旋锁
自旋锁的特点是在没有获取到锁时既锁已经被添加,还没有被解开时.
OSSpinLock处于忙等状态,一直占用CPU资源,类似如下伪代码:
while(锁没解开);
关于优先级反转问题
由于线程调度,每条线程的分配时间权重不一样,当权重小的线程先进入OSSpinLock优先加锁,
当权重大的线程再来访问,就阻塞在这,可能权重大的线程会一直分配到cpu所以一直会进来,
但是因为有锁,只能等待,权重小的线程得不到cpu资源分配,所以不会解锁,造成一定程度的死锁.
2、互斥锁
os_unfair_lock 、pthread_mutex是典型的互斥锁,在没有获取到锁时既锁已经被添加,还没有被解开时.
它们都会让当前线程进入休眠状态既不占用CPU资源,但是为什么,互斥锁比自旋锁的效率低呢,
是因为休眠,以及唤醒休眠,比忙等更加消耗CPU资源.
NSLock 封装的pthread_mutex的PTHREAD_MUTEX_NORMAL 模式
NSRecursiveLock 封装的pthread_mutex的PTHREAD_MUTEX_RECURSIVE 模式
3、条件锁
在一定条件下,让其等待休眠,并放开锁,等接收到信号或者广播,会从新唤起线程,并重新加锁.
pthread_cond_wait(&_cond, &_mutex);
// 信号
pthread_cond_signal(&_cond);
// 广播
pthread_cond_broadcast(&_cond);
像NSCondition封装了pthread_mutex的以上几个函数
NSConditionLock封装了NSCondition
4、递归锁
递归锁的主要意思是,同一条线程可以加多把锁.什么意思呢,就是相同的线程访问一段代码,
如果是加锁的可以继续加锁,继续往下走,不同线程来访问这段代码时,发现有锁要等待所有锁解开之后才可以继续往下走.
NSRecursiveLock 封装的pthread_mutex 的PTHREAD_MUTEX_RECURSIVE模式
