iOS多线程之线程锁

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

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

  • @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的安全性。

©著作权归作者所有,转载或内容合作请联系作者
平台声明：文章内容（如有图片或视频亦包括在内）由作者上传并发布，文章内容仅代表作者本人观点，简书系信息发布平台，仅提供信息存储服务。

推荐阅读更多精彩内容

  • iOS中的锁
    锁是一种同步机制，用于多线程环境中对资源访问的限制iOS中常见锁的性能对比图（摘自：ibireme）： iOS锁的...
    LiLS阅读 1,560评论 0赞 6
  • iOS多线程-各种线程锁的简单介绍
    demo下载 建议一边看文章，一边看代码。 声明：关于性能的分析是基于我的测试代码来的，我也看到和网上很多测试结果...
    炸街程序猿阅读 808评论 0赞 2
  • iOS多线程-各种线程锁的简单介绍
    线程安全是怎么产生的 常见比如线程内操作了一个线程外的非线程安全变量，这个时候一定要考虑线程安全和同步。 - (v...
    幽城88阅读 690评论 0赞 0
  • 线程安全-锁
    一、前言 前段时间看了几个开源项目，发现他们保持线程同步的方式各不相同，有@synchronized、NSLock...
    稻春阅读 471评论 0赞 0
  • 不断精进，才能让自己始终处于主动
    今天继续听书，热播有声书《大江大河》，听到一个金句： 人不可能永远处于从属地位，人得在工作之外有所布局，主动是最好...
    吟花飞语阅读 926评论 0赞 0