美文网首页学习准备
1、谈下iOS开发中知道的哪些锁? 哪个性能最差?SD和AFN使

1、谈下iOS开发中知道的哪些锁? 哪个性能最差?SD和AFN使

作者: 婕妤露 | 来源:发表于2017-11-08 18:27 被阅读408次

    1、谈下iOS开发中知道的哪些锁? 哪个性能最差?SD和AFN使用的哪个? 一般开发中你最常用哪个? 哪个锁apple存在问题又是什么问题?

    我们在使用多线程的时候多个线程可能会访问同一块资源,这样就很容易引发数据错乱和数据安全等问题。这时候我们需要保证每次只有一个线程访问这一块资源,锁应运而生。

    • @synchronized
    • NSLock对象锁
    • NSRecursiveLock 递归锁
    • NSCondition
    • NSConditionLock 条件锁
    • pthread_mutex 互斥锁(C语言)
    • dispatch_semaphore 信号量实现加锁(GCD)
    • OSSpinLock

    1)、@synchronized关键字加锁 互斥锁,性能较差不推荐使用

    @synchronized(这里添加一个OC对象,一般使用self){
    这里写要加锁的代码
    }
    注意点
    a.加锁的代码尽量少
    b.添加的OC对象必须在多个线程中都是同一对象
    c.优点是不需要显示创建锁对象,便可以实现锁的机制。
    d.@synchronized块会隐式的添加一个异常处理例程来保护代码,该处理例程会在异常抛出的时候自动释放互斥锁。所以如果不想让隐式的异常处理例程带来额外的开销,可以考虑使用该锁对象。

    2)、NSLock互斥锁 不能多次调用lock方法,会造成死锁

    在Cocoa程序中NSLock中实现了一个简单的互斥锁。所有锁(包括NSLock)的接口实际都是通过NSLocking协议定义的,它定义了lock和unlock方法。你使用这些方法来获取和释放该锁。
    NSLock类还增加了tryLock和lockBeforeDate:方法。tryLock视图获取一个锁,但是如果锁不可用的时候,它不会阻塞线程,相反,它只是返回NO。
    lockBeforeDate:方法视图获取一个锁,但是如果锁没有在规定的时间内被获取,它会让线程从阻塞状态变为非阻塞状态(或者返回NO)。

    3)、NSRecursiveLock 递归锁

    使用锁最容易犯的一个错误就是在递归或循环中造成死锁,在NSLock锁中,如果锁多次的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,而不会造成死锁。
    递归锁会跟踪它被多次lock。每次成功的lock都必须平衡调用unlock操作。
    只有所有的锁住和解锁操作都平衡的时候,锁才真正被释放给其他线程获得。

      //创建锁
    _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条件锁

    //主线程中
    NSConditionLock *theLock = [[NSConditionLock alloc] init];
    //线程1
    dispatch_async(self.concurrentQueue, ^{
        for (int i=0;i<=3;i++)
        {
            [theLock lock];
            NSLog(@"thread1:%d",i);
            sleep(1);
            [theLock unlockWithCondition:i];
        }
    });
    
    //线程2
    dispatch_async(self.concurrentQueue, ^{
        [theLock lockWhenCondition:2];
        NSLog(@"thread2");
        [theLock unlock];
    });
    
    图片.png

    在线程1中的加锁使用了lock,是不需要条件的,所以顺利的就锁住了。
    unlockWithCondition:在开锁的同时设置了一个整形的条件2。
    线程2则需要一把被标识为2的钥匙,所以当线程1循环到i = 2时,线程2的任务才执行。
    NSConditionLock也跟其他的锁一样,是需要lock与unlock对应的,只是lock,lockWhenCondition:与unlock,unlockWithCondition:是可以随意组合的,当然这是与你的需求相关的。

    5)、NSCondition

    看字面意思很好理解:
    wait:进入等待状态
    waitUntilDate::让一个线程等待一定的时间
    signal:唤醒一个等待的线程
    broadcast:唤醒所有等待的线程
    例子:

    等待2秒
    NSCondition *cLock = [NSCondition new];
    //线程1
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    NSLog(@"start");
    [cLock lock];
    [cLock waitUntilDate:[NSDate dateWithTimeIntervalSinceNow:2]];
    NSLog(@"线程1");
    [cLock unlock];
    });
    
    图片.png

    唤醒一个等待线程

    NSCondition *cLock = [NSCondition new];
    //线程1
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    [cLock lock];
    NSLog(@"线程1加锁成功");
    [cLock wait];
    NSLog(@"线程1");
    [cLock unlock];
    });
    
    //线程2
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    [cLock lock];
    NSLog(@"线程2加锁成功");
    [cLock wait];
    NSLog(@"线程2");
    [cLock unlock];
    });
    
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    sleep(2);
    NSLog(@"唤醒一个等待的线程");
    [cLock signal];
    });
    
    结果: 图片.png

    唤醒所有等待的线程

    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    sleep(2);
    NSLog(@"唤醒所有等待的线程");
    [cLock broadcast];
    });
    
    运行结果: 图片.png

    6)、pthread_mutex互斥锁

    __block pthread_mutex_t mutex;
    pthread_mutex_init(&mutex, NULL);
    //线程1
    dispatch_async(self.concurrentQueue), ^{
      pthread_mutex_lock(&mutex);
      NSLog(@"任务1");
      sleep(2);
      pthread_mutex_unlock(&mutex);
    });
    
    //线程2
    dispatch_async(self.concurrentQueue), ^{
      sleep(1);
      pthread_mutex_lock(&mutex);
      NSLog(@"任务2");
      pthread_mutex_unlock(&mutex);
    });
    

    7)、dispatch_semaphore信号量实现加锁

    GCD中也已经提供了一种信号机制,使用它我们也可以来构建一把锁

    dispatch_semaphore_t signal = dispatch_semaphore_create(1); //传入值必须 >=0, 若传入为0则阻塞线程并等待timeout,时间到后会执行其后的语句
    dispatch_time_t overTime = dispatch_time(DISPATCH_TIME_NOW, 3.0f * NSEC_PER_SEC);
    //线程1
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    NSLog(@"线程1 等待ing");
    dispatch_semaphore_wait(signal, overTime); //signal 值 -1
    NSLog(@"线程1");
    dispatch_semaphore_signal(signal); //signal 值 +1
    NSLog(@"线程1 发送信号");
    NSLog(@"--------------------------------------------------------");
       });
      //线程2
     dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    NSLog(@"线程2 等待ing");
    dispatch_semaphore_wait(signal, overTime);
    NSLog(@"线程2");
    dispatch_semaphore_signal(signal);
    NSLog(@"线程2 发送信号");
    });
    

    dispatch_semaphore_create(1): 传入值必须 >=0, 若传入为 0 则阻塞线程并等待timeout,时间到后会执行其后的语句
    dispatch_semaphore_wait(signal, overTime):可以理解为 lock,会使得 signal 值 -1
    dispatch_semaphore_signal(signal):可以理解为 unlock,会使得 signal 值 +1
    运行结果


    图片.png

    8)、OSSpinLock(不建议使用)

    新版 iOS 中,系统维护了 5 个不同的线程优先级/QoS: background,utility,default,user-initiated,user-interactive。高优先级线程始终会在低优先级线程前执行,一个线程不会受到比它更低优先级线程的干扰。这种线程调度算法会产生潜在的优先级反转问题,从而破坏了 spin lock。

    具体来说,如果一个低优先级的线程获得锁并访问共享资源,这时一个高优先级的线程也尝试获得这个锁,它会处于 spin lock 的忙等状态从而占用大量 CPU。此时低优先级线程无法与高优先级线程争夺 CPU 时间,从而导致任务迟迟完不成、无法释放 lock。这并不只是理论上的问题,libobjc 已经遇到了很多次这个问题了,于是苹果的工程师停用了 OSSpinLock。

    AFN 3.1 .0 使用NSlock 、@synchronized和 dispatch_semaphore_t信号量实现加锁(老版本有使用过NSRecursiveLock) SDWebImage 使用@synchronized

    相关文章

      网友评论

        本文标题:1、谈下iOS开发中知道的哪些锁? 哪个性能最差?SD和AFN使

        本文链接:https://www.haomeiwen.com/subject/lpmemxtx.html