iOS多线程之线程锁

最新推荐文章于 2024-03-13 17:20:58 发布

一个默默无闻的程序猿

最新推荐文章于 2024-03-13 17:20:58 发布

阅读量723

点赞数

分类专栏： iOS编程笔记文章标签：多线程线程锁 synchronized NSLock dispatch_semaphore_t

本文链接：https://blog.csdn.net/yujianxiang666/article/details/99706904

版权

iOS编程同时被 2 个专栏收录

153 篇文章 0 订阅

订阅专栏

笔记

61 篇文章 0 订阅

订阅专栏

在多线程开发中，不可忽视的一个问题就是多个线程同时访问同一个资源时，会造成脏数据等预想不到的结果，为了避免这种现象，我们需要在访问资源的时候添加线程锁，来控制访问。

添加线程锁的方式在这主要讲三种方式：

@synchronized隐式创建锁对象
NSLock
GCD的dispatch_semaphore_t信号机制

一、@synchronized( )

@synchronized()内的对象设定为锁的唯一标识，只有标识相同时，才满足互斥

-(void)testSynchronized
{
    GCDcreate *someone = [GCDcreate new];
    //线程A
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        @synchronized (someone) {
            NSLog(@"线程A=%@",[NSThread currentThread]);
            someone.name = @"我是线程A";
            [NSThread sleepForTimeInterval:5];
        }
    });
    //线程B
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        @synchronized (someone) {
            NSLog(@"线程B=%@",[NSThread currentThread]);
            someone.name = @"我是线程B";
        }
    });
}

二、NSLock

NSLock的lock和unlock必须在同一线程；同一线程lock后，未unlock前再lock会导致永久性死锁。

-(void)testNSLock
{
    GCDcreate *someone = [GCDcreate new];
    //创建锁对象
    NSLock *alock = [[NSLock alloc] init];
    //线程A
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        if ([alock tryLock]) //上锁 或 [alock lock]
        {
            NSLog(@"线程A=%@",[NSThread currentThread]);
            someone.name = @"我是线程A";
            [NSThread sleepForTimeInterval:5];
            //开锁
            [alock unlock];
        }
    });
    //线程B
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        if ([alock tryLock]) //上锁 或 [alock lock]
        {
            NSLog(@"线程B=%@",[NSThread currentThread]);
            someone.name = @"我是线程B";
            //开锁
            [alock unlock];
        }
    });
}

三、dispatch_semaphore_t

在上一篇GCD用法详解中讲解到dispatch_semaphore_t信号量的用法，它的用法很灵活，其中一种就是可以当成线程锁来用。

这里拿一个现实中的例子来解释一下它的用法，再买火车的时候，会有很多窗口或代售点出售火车票，那么火车票的余票数是保存在数据库中的，每个出售的地方都会去读写这个余票数。如果不加锁的话，就会出现多个窗口买同一张票的情况。比如：

//初始化火车票数量、卖票窗口、并开始卖票
- (void)testGCD {
    NSLog(@"currentThread---%@",[NSThread currentThread]);  // 打印当前线程
    NSLog(@"semaphore---begin");
    
    self.ticketSurplusCount = 50;
    // queue1 代表北京火车票售卖窗口
    dispatch_queue_t queue1 = dispatch_queue_create("com.jzsec.GCDtest", DISPATCH_QUEUE_CONCURRENT);
    //queue2 代表上海火车票售卖窗口
    dispatch_queue_t queue2 = dispatch_queue_create("com.jzsec.GCDtest1", DISPATCH_QUEUE_CONCURRENT);
    
    __weak typeof(self) weakSelf = self;
    dispatch_async(queue1, ^{
        [weakSelf saleTicketSafe];
    });
    
    dispatch_async(queue2, ^{
        [weakSelf saleTicketSafe];
    });
}

//售卖火车票
- (void)saleTicketSafe {
    while (1) {
        if (self.ticketSurplusCount > 0) {  //如果还有票，继续售卖
            self.ticketSurplusCount--;
            NSLog(@"%@", [NSString stringWithFormat:@"剩余票数：%d 窗口：%@", self.ticketSurplusCount, [NSThread currentThread]]);
            [NSThread sleepForTimeInterval:0.2];
        } else { //如果已卖完，关闭售票窗口
            NSLog(@"所有火车票均已售完");
            break;
        }
    }   
}

结果比较长就不全贴出来了，其中一段就可以看出问题：

...
2019-08-09 18:36:32.036600+0800 GCDtest[2616:300126] 剩余票数：40 窗口：<NSThread: 0x600001b8c080>{number = 3, name = (null)}
2019-08-09 18:36:32.036600+0800 GCDtest[2616:300123] 剩余票数：39 窗口：<NSThread: 0x600001b87f80>{number = 4, name = (null)}
2019-08-09 18:36:32.237564+0800 GCDtest[2616:300123] 剩余票数：38 窗口：<NSThread: 0x600001b87f80>{number = 4, name = (null)}
2019-08-09 18:36:32.237565+0800 GCDtest[2616:300126] 剩余票数：38 窗口：<NSThread: 0x600001b8c080>{number = 3, name = (null)}
2019-08-09 18:36:32.442719+0800 GCDtest[2616:300123] 剩余票数：37 窗口：<NSThread: 0x600001b87f80>{number = 4, name = (null)}
2019-08-09 18:36:32.442719+0800 GCDtest[2616:300126] 剩余票数：37 窗口：<NSThread: 0x600001b8c080>{number = 3, name = (null)}
2019-08-09 18:36:32.644508+0800 GCDtest[2616:300123] 剩余票数：36 窗口：<NSThread: 0x600001b87f80>{number = 4, name = (null)}
2019-08-09 18:36:32.644508+0800 GCDtest[2616:300126] 剩余票数：35 窗口：<NSThread: 0x600001b8c080>{number = 3, name = (null)}
...

这里出现两个37和两个38，就是因为两个线程同时读写self.ticketSurplusCount余票数造成的，如果线程更多的话，后果不堪设想。

所以我们对程序加上线程锁，改造如下：

/**
 * 线程安全：使用 semaphore 加锁
 * 初始化火车票数量、卖票窗口(线程安全)、并开始卖票
 */
- (void)testGCD {
    NSLog(@"currentThread---%@",[NSThread currentThread]);  // 打印当前线程
    NSLog(@"semaphore---begin");
    
    semaphoreLock = dispatch_semaphore_create(1);

    self.ticketSurplusCount = 50;    
    // queue1 代表北京火车票售卖窗口
    dispatch_queue_t queue1 = dispatch_queue_create("com.jzsec.GCDtest", DISPATCH_QUEUE_CONCURRENT);
    //queue2 代表上海火车票售卖窗口
    dispatch_queue_t queue2 = dispatch_queue_create("com.jzsec.GCDtest1", DISPATCH_QUEUE_CONCURRENT);
    
    __weak typeof(self) weakSelf = self;
    dispatch_async(queue1, ^{
        [weakSelf saleTicketSafe];
    });
    
    dispatch_async(queue2, ^{
        [weakSelf saleTicketSafe];
    });
}

/**
 * 售卖火车票(线程安全)
 */
- (void)saleTicketSafe {
    while (1) {
        // 相当于加锁
        dispatch_semaphore_wait(semaphoreLock, DISPATCH_TIME_FOREVER);
        
        if (self.ticketSurplusCount > 0) {  //如果还有票，继续售卖
            self.ticketSurplusCount--;
            NSLog(@"%@", [NSString stringWithFormat:@"剩余票数：%d 窗口：%@", self.ticketSurplusCount, [NSThread currentThread]]);
            [NSThread sleepForTimeInterval:0.2];
        } else { //如果已卖完，关闭售票窗口
            NSLog(@"所有火车票均已售完");   
            // 相当于解锁
            dispatch_semaphore_signal(semaphoreLock);
            break;
        }   
        // 相当于解锁
        dispatch_semaphore_signal(semaphoreLock);
    }   
}

2019-08-09 18:41:29.843021+0800 GCDtest[2660:303158] currentThread---<NSThread: 0x600002f86a00>{number = 1, name = main}
2019-08-09 18:41:29.843230+0800 GCDtest[2660:303158] semaphore---begin
2019-08-09 18:41:29.844289+0800 GCDtest[2660:303249] 剩余票数：49 窗口：<NSThread: 0x600002fd6440>{number = 3, name = (null)}
2019-08-09 18:41:30.048023+0800 GCDtest[2660:303248] 剩余票数：48 窗口：<NSThread: 0x600002fd7400>{number = 4, name = (null)}
2019-08-09 18:41:30.252102+0800 GCDtest[2660:303249] 剩余票数：47 窗口：<NSThread: 0x600002fd6440>{number = 3, name = (null)}
2019-08-09 18:41:30.453306+0800 GCDtest[2660:303248] 剩余票数：46 窗口：<NSThread: 0x600002fd7400>{number = 4, name = (null)}
2019-08-09 18:41:30.657614+0800 GCDtest[2660:303249] 剩余票数：45 窗口：<NSThread: 0x600002fd6440>{number = 3, name = (null)}
... 省略 ...
2019-08-09 18:41:39.179921+0800 GCDtest[2660:303249] 剩余票数：3 窗口：<NSThread: 0x600002fd6440>{number = 3, name = (null)}
2019-08-09 18:41:39.381520+0800 GCDtest[2660:303248] 剩余票数：2 窗口：<NSThread: 0x600002fd7400>{number = 4, name = (null)}
2019-08-09 18:41:39.583975+0800 GCDtest[2660:303249] 剩余票数：1 窗口：<NSThread: 0x600002fd6440>{number = 3, name = (null)}
2019-08-09 18:41:39.786290+0800 GCDtest[2660:303248] 剩余票数：0 窗口：<NSThread: 0x600002fd7400>{number = 4, name = (null)}
2019-08-09 18:41:39.988175+0800 GCDtest[2660:303249] 所有火车票均已售完
2019-08-09 18:41:39.988514+0800 GCDtest[2660:303248] 所有火车票均已售完

此时就可以看到与票数是依次正确减少的，这种访问数据才是线程安全的。

初始semaphoreLock为1，第一个线程进入saleTicketSafe时dispatch_semaphore_wait使semaphoreLock-1为0，第二个线程再进入saleTicketSafe时dispatch_semaphore_wait使semaphoreLock-1为-1，第二个线程就会一直等待，等第一个线程扣除余票后dispatch_semaphore_signal使semaphoreLock+1为0，此时正在等待中的第二个线程开始执行；

以此类推，总是同时只有一个线程在访问它们的共享资源self.ticketSurplusCount，保证了self.ticketSurplusCount的安全性。