iOS 多线程的安全隐患（线程锁）

2021-03-28 本文已影响0人 XieHenry

资源共享
1块资源可能会被多个线程共享，也就是多个线程可能会访问同一块资源
比如多个线程访问同一个对象、同一个变量、同一个文件
当多个线程访问同一块资源时，很容易引发数据错乱和数据安全问题

一.错误示例

1.1 卖票未使用线程锁之前的问题

示例图.png

- (void)viewDidLoad {
    [super viewDidLoad];

    [self saleTickets];
}

-(void)saleTicket {
    int oldTicketsCount = self.ticketsCount;
   // sleep(.2); //如果休眠一会，会更加明显
    oldTicketsCount --;
    self.ticketsCount = oldTicketsCount;
    
    NSLog(@"还剩%d张票 - %@",oldTicketsCount,[NSThread currentThread]);
}

-(void)saleTickets {
    self.ticketsCount = 15;
    dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
    dispatch_async(queue, ^{
        for (int i = 0; i<5; i++) {
            [self saleTicket];
        }
    });
    
    dispatch_async(queue, ^{
        for (int i = 0; i<5; i++) {
            [self saleTicket];
        }
    });
    
    dispatch_async(queue, ^{
        for (int i = 0; i<5; i++) {
            [self saleTicket];
        }
    });
}

打印结果会出现错误：没有卖完，而且还有结果相等的时候。

image.png

1.2 存取钱未使用线程锁之前的问题

示例图.png

- (void)viewDidLoad {
    [super viewDidLoad];
    
    [self moneyTest];
}
//存取钱演示
-(void)moneyTest {
    self.money = 100;
    dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
    dispatch_async(queue, ^{
        for (int i = 0; i<10; i++) {
            [self saveMoney];
        }
    });
    
    dispatch_async(queue, ^{
        for (int i = 0; i<10; i++) {
            [self drawMoney];
        }
    });
}
//存钱
-(void)saveMoney {
    int oldMoney = self.money;
    sleep(.2); //如果休眠一会，会更加明显
    oldMoney += 50;
    self.money = oldMoney;
    NSLog(@"存50，还剩%d元 - %@",oldMoney,[NSThread currentThread]);
}
//取钱
-(void)drawMoney {
    int oldMoney = self.money;
    sleep(.2); //如果休眠一会，会更加明显
    oldMoney -= 20;
    self.money = oldMoney;
    NSLog(@"取20，还剩%d元 - %@",oldMoney,[NSThread currentThread]);
}

打印结果

image.png

二.iOS中的线程同步方案

OSSpinLock（自旋锁）
os_unfair_lock
pthread_mutex（互斥锁）
dispatch_semaphore （信号量实现加锁）
dispatch_queue(DISPATCH_QUEUE_SERIAL)
NSLock（对象锁）
NSRecursiveLock （递归锁）
NSCondition （条件锁）
NSConditionLock（条件锁）
@synchronized

三.代码示范

封装demo

3.1 OSSpinLock(该方法已废弃，不推荐使用)

OSSpinLock叫做”自旋锁”，等待锁的线程会处于忙等（busy-wait）状态，一直占用着CPU资源
目前已经不再安全，可能会出现优先级反转问题
如果等待锁的线程优先级较高，它会一直占用着CPU资源，优先级低的线程就无法释放锁
需要导入头文件#import <libkern/OSAtomic.h>

image.png

卖票问题解决方案：

@property (assign, nonatomic) OSSpinLock ticketLock;
self.ticketLock = OS_SPINLOCK_INIT;

- (void)__saleTicket {
    OSSpinLockLock(&_ticketLock);
    [super __saleTicket];
    OSSpinLockUnlock(&_ticketLock);
}

3.2 os_unfair_lock

os_unfair_lock用于取代不安全的OSSpinLock ，从iOS10开始才支持
从底层调用看，等待os_unfair_lock锁的线程会处于休眠状态，并非忙等
需要导入头文件#import <os/lock.h>

image.png

卖票问题解决方案：

@property (assign, nonatomic) os_unfair_lock ticketLock;
self.ticketLock = OS_UNFAIR_LOCK_INIT;

- (void)__saleTicket {
    os_unfair_lock_lock(&_ticketLock);
    [super __saleTicket];
    os_unfair_lock_unlock(&_ticketLock);
}

3.3 pthread_mutex

mutex叫做”互斥锁”，等待锁的线程会处于休眠状态
需要导入头文件#import <pthread.h>

pthread_mutex .png

pthread_mutex – 递归锁.png

pthread_mutex – 条件 .png

卖票问题解决方案：

@property (assign, nonatomic) pthread_mutex_t ticketMutex;

- (void)__initMutex:(pthread_mutex_t *)mutex {
    // 初始化锁
    pthread_mutex_init(mutex, NULL);
}

[self __initMutex:&_ticketMutex];

- (void)__saleTicket {
    pthread_mutex_lock(&_ticketMutex);
    [super __saleTicket];
    pthread_mutex_unlock(&_ticketMutex);
}

- (void)dealloc {
    pthread_mutex_destroy(&_ticketMutex);
}

问题1:这段代码有问题吗？

- (void)otherTest {
    pthread_mutex_lock(&_mutex);
    NSLog(@"%s", __func__);
    [self otherTest2];
    pthread_mutex_unlock(&_mutex);
}

- (void)otherTest2 {
    pthread_mutex_lock(&_mutex);
    NSLog(@"%s", __func__);
    pthread_mutex_unlock(&_mutex);
}

会造成死锁。可以通过在otherTest2内使用另外一把锁即可解决。

问题2:这段代码有问题吗？

- (void)otherTest {
    pthread_mutex_lock(&_mutex);
    
    NSLog(@"%s", __func__);
    [self otherTest];
    pthread_mutex_unlock(&_mutex);
}

也会造成死锁。可以通过一个递归锁解决。方案如下：

- (void)__initMutex:(pthread_mutex_t *)mutex {
    // 递归锁：允许同一个线程对一把锁进行重复加锁 PTHREAD_MUTEX_RECURSIVE(递归锁)
    
    // 初始化属性
    pthread_mutexattr_t attr;
    pthread_mutexattr_init(&attr);
    pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
    // 初始化锁
    pthread_mutex_init(mutex, &attr);
    // 销毁属性
    pthread_mutexattr_destroy(&attr);
}

3.4 NSLock（对象锁），NSRecursiveLock（递归锁）

image.png

卖票问题解决方案：

@property (strong, nonatomic) NSLock *ticketLock;
self.ticketLock = [[NSLock alloc] init];

- (void)__saleTicket {
    [self.ticketLock lock];
    [super __saleTicket];
    [self.ticketLock unlock];
}

3.5 NSCondition（对pthread_mutex的mutex和cond的封装）

image.png

3.6 NSConditionLock

NSConditionLock是对NSCondition的进一步封装，可以设置具体的条件值

image.png

使用示例：(可以根据条件值进行顺序执行)

@property (strong, nonatomic) NSConditionLock *conditionLock;
self.conditionLock = [[NSConditionLock alloc] initWithCondition:1];

- (void)otherTest {
    [[[NSThread alloc] initWithTarget:self selector:@selector(__one) object:nil] start];
    
    [[[NSThread alloc] initWithTarget:self selector:@selector(__two) object:nil] start];
    
    [[[NSThread alloc] initWithTarget:self selector:@selector(__three) object:nil] start];
}

- (void)__one {
    [self.conditionLock lock];
    
    NSLog(@"__one");
    sleep(1);
    
    [self.conditionLock unlockWithCondition:2];
}

- (void)__two {
    [self.conditionLock lockWhenCondition:2];
    
    NSLog(@"__two");
    sleep(1);
    
    [self.conditionLock unlockWithCondition:3];
}

- (void)__three {
    [self.conditionLock lockWhenCondition:3];
    
    NSLog(@"__three");
    
    [self.conditionLock unlock];
}

3.7 dispatch_queue

直接使用GCD的串行队列，也是可以实现线程同步的

卖票解决方案：

@property (strong, nonatomic) dispatch_queue_t ticketQueue;
self.ticketQueue = dispatch_queue_create("ticketQueue", DISPATCH_QUEUE_SERIAL);

- (void)__saleTicket
{
    dispatch_sync(self.ticketQueue, ^{
        [super __saleTicket];
    });
}

3.8 dispatch_semaphore

semaphore叫做”信号量”
信号量的初始值，可以用来控制线程并发访问的最大数量
信号量的初始值为1，代表同时只允许1条线程访问资源，保证线程同步

image.png

卖票解决方案：

@property (strong, nonatomic) dispatch_semaphore_t ticketSemaphore;
self.ticketSemaphore = dispatch_semaphore_create(1);

- (void)__saleTicket {
    dispatch_semaphore_wait(self.ticketSemaphore, DISPATCH_TIME_FOREVER);
    
    [super __saleTicket];
    
    dispatch_semaphore_signal(self.ticketSemaphore);
}

3.9 @synchronized

@synchronized是对mutex递归锁的封装
源码查看：objc4中的objc-sync.mm文件
@synchronized(obj)内部会生成obj对应的递归锁，然后进行加锁、解锁操作

image.png

卖票解决方案：

- (void)__saleTicket {
    @synchronized([self class]) {
        [super __saleTicket];
    }
}

iOS 多线程的安全隐患（线程锁）

一.错误示例

1.1 卖票未使用线程锁之前的问题

1.2 存取钱未使用线程锁之前的问题

二.iOS中的线程同步方案

三.代码示范

3.1 OSSpinLock(该方法已废弃，不推荐使用)

3.2 os_unfair_lock

3.3 pthread_mutex

3.4 NSLock（对象锁），NSRecursiveLock（递归锁）

3.5 NSCondition（对pthread_mutex的mutex和cond的封装）

3.6 NSConditionLock

3.7 dispatch_queue

3.8 dispatch_semaphore

3.9 @synchronized

猜你喜欢

热点阅读