博客> iOS 保证线程同步方式&性能对比
iOS 保证线程同步方式&性能对比
2017-11-24 16:29 评论:0 阅读:732 流浪猫_qihr
ios GCD 性能 线程锁

背景

IOS中保持线程同步的常用技术:

  • @synchronized
  • NSLock
  • NSRecursiveLock
  • dispatch_semaphore
  • NSCondition
  • pthread_mutex
  • OSSpinLock。 他们的实现机制各不相同,性能也各不一样。而我们平时用的最多的@synchronized是性能最差的。

    本人开发时候,第一选择为NSRecursiveLock.

下面我们先分别介绍每个加锁方式的使用,在使用一个案例来对他们进行性能对比。

介绍与使用

@synchronized

NSObject *obj = [[NSObject alloc] init];
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    @synchronized(obj) {
         NSLog(@"需要线程同步的操作1 开始");
         sleep(3); 
         NSLog(@"需要线程同步的操作1 结束");
     } 
  }); 

dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{ 
    sleep(1); 
    @synchronized(obj) { 
         NSLog(@"需要线程同步的操作2"); 
     } 
});

@synchronized(obj)指令使用的obj为该锁的唯一标识,只有当标识相同时,才为满足互斥,如果线程2中的@synchronized(obj)改为@synchronized(self),刚线程2就不会被阻塞,@synchronized指令实现锁的优点就是我们不需要在代码中显式的创建锁对象,便可以实现锁的机制,但作为一种预防措施,@synchronized块会隐式的添加一个异常处理例程来保护代码,该处理例程会在异常抛出的时候自动的释放互斥锁。所以如果不想让隐式的异常处理例程带来额外的开销,你可以考虑使用锁对象。 上面结果的执行结果为: 2016-07-23 09:40:24.051 ThreadTest[13438:385647] 需要线程同步的操作1 开始 2016-07-23 09:40:27.054 ThreadTest[13438:385647] 需要线程同步的操作1 结束 2016-07-23 09:40:27.054 ThreadTest[13438:385646] 需要线程同步的操作2

dispatch_semaphore


dispatch_semaphore_t signal = dispatch_semaphore_create(1); 
dispatch_time_t overTime = dispatch_time(DISPATCH_TIME_NOW, 3 * NSEC_PER_SEC);
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{

dispatch_semaphore_wait(signal, overTime); 
        NSLog(@"需要线程同步的操作1 开始"); 
        sleep(2);
        NSLog(@"需要线程同步的操作1 结束");
        dispatch_semaphore_signal(signal); 
}); 

dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{ 
        sleep(1); 
        dispatch_semaphore_wait(signal, overTime); 
        NSLog(@"需要线程同步的操作2"); 
        dispatch_semaphore_signal(signal); 
});

dispatch_semaphore是GCD用来同步的一种方式,与他相关的共有三个函数,分别是dispatch_semaphore_create,dispatch_semaphore_signal,dispatch_semaphore_wait。

  1. dispatch_semaphore_create的声明为:   dispatch_semaphore_t  dispatch_semaphore_create(long value);   传入的参数为long,输出一个dispatch_semaphore_t类型且值为value的信号量。   值得注意的是,这里的传入的参数value必须大于或等于0,否则dispatch_semaphore_create会返回NULL。
  2. dispatch_semaphore_signal的声明为:   long dispatch_semaphore_signal(dispatch_semaphore_t dsema)   这个函数会使传入的信号量dsema的值加1;
  3.  dispatch_semaphore_wait的声明为:   long dispatch_semaphore_wait(dispatch_semaphore_t dsema, dispatch_time_t timeout);   这个函数会使传入的信号量dsema的值减1;这个函数的作用是这样的,如果dsema信号量的值大于0,该函数所处线程就继续执行下面的语句,并且将信号量的值减1;如果desema的值为0,那么这个函数就阻塞当前线程等待timeout(注意timeout的类型为dispatch_time_t,不能直接传入整形或float型数),如果等待的期间desema的值被dispatch_semaphore_signal函数加1了,且该函数(即dispatch_semaphore_wait)所处线程获得了信号量,那么就继续向下执行并将信号量减1。如果等待期间没有获取到信号量或者信号量的值一直为0,那么等到timeout时,其所处线程自动执行其后语句。 dispatch_semaphore 是信号量,但当信号总量设为 1 时也可以当作锁来。在没有等待情况出现时,它的性能比 pthread_mutex 还要高,但一旦有等待情况出现时,性能就会下降许多。相对于 OSSpinLock 来说,它的优势在于等待时不会消耗 CPU 资源。 如上的代码,如果超时时间overTime设置成>2,可完成同步操作。如果overTime<2 xss=removed xss=removed> { @private void *_priv; }
    • (BOOL)tryLock;
    • (BOOL)lockBeforeDate:(NSDate )limit; @property (nullable, copy) NSString name NS_AVAILABLE(10_5, 2_0); @end
      
      ##**NSRecursiveLock递归锁**
      ```Objc
      //NSLock *lock = [[NSLock alloc] init];
      NSRecursiveLock *lock = [[NSRecursiveLock alloc] init];
      dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{ 
      static void (^RecursiveMethod)(int); 
      RecursiveMethod = ^(int value) { 
      [lock lock]; 
      if (value > 0) { 
          NSLog(@"value = %d", value); 
          sleep(1); 
          RecursiveMethod(value - 1); 
      } 
      [lock unlock]; 
      };
      RecursiveMethod(5); 
      });
这段代码是一个典型的死锁情况。在我们的线程中,RecursiveMethod是递归调用的。如果使用NSLock,每次进入这个block时,都会去加一次锁,而从第二次开始,由于锁已经被使用了且没有解锁,所以它需要等待锁被解除,这样就导致了死锁,线程被阻塞住了。调试器中会输出如下信息:
2016-07-23 10:09:50.932 ThreadTest[13568:398209] value = 5 
2016-07-23 10:09:51.933 ThreadTest[13568:398209]  -[NSLock lock]: deadlock (<NSLock> '(null)')
2016-07-23 10:09:51.934 ThreadTest[13568:398209]   Break on _NSLockError() to debug.
在这种情况下,我们就可以使用NSRecursiveLock。它可以允许同一线程多次加锁,而不会造成死锁。递归锁会跟踪它被lock的次数。每次成功的lock都必须平衡调用unlock操作。只有所有达到这种平衡,锁最后才能被释放,以供其它线程使用。
如果我们将NSLock代替为NSRecursiveLock,上面代码则会正确执行。
 2016-07-23 10:13:08.465 ThreadTest[13593:400360] value = 5
 2016-07-23 10:13:09.468 ThreadTest[13593:400360] value = 4
 2016-07-23 10:13:10.472 ThreadTest[13593:400360] value = 3
 2016-07-23 10:13:11.474 ThreadTest[13593:400360] value = 2
 2016-07-23 10:13:12.478 ThreadTest[13593:400360] value = 1
如果需要其他功能,源码定义如下:
```Objc
@interface NSRecursiveLock : NSObject <NSLocking> {
@private 
    void *_priv;
}

- (BOOL)tryLock;
- (BOOL)lockBeforeDate:(NSDate *)limit;
@property (nullable, copy) NSString *name NS_AVAILABLE(10_5, 2_0);

@end

NSConditionLock条件锁


NSConditionLock *lock = [[NSConditionLock alloc] init];
NSMutableArray *products = [NSMutableArray array]; 
NSInteger HAS_DATA = 1; 
NSInteger NO_DATA = 0;

dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{ 
    while (1) { 
        [lock lockWhenCondition:NO_DATA]; 
        [products addObject:[[NSObject alloc] init]]; 
        NSLog(@"produce a product,总量:%zi",products.count); 
        [lock unlockWithCondition:HAS_DATA]; 
        sleep(1); 
   } 
}); 

dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{ 
    while (1) { 
         NSLog(@"wait for product"); 
         [lock lockWhenCondition:HAS_DATA]; 
         [products removeObjectAtIndex:0]; 
         NSLog(@"custome a product"); 
         [lock unlockWithCondition:NO_DATA]; 
    } 
});

当我们在使用多线程的时候,有时一把只会lock和unlock的锁未必就能完全满足我们的使用。因为普通的锁只能关心锁与不锁,而不在乎用什么钥匙才能开锁,而我们在处理资源共享的时候,多数情况是只有满足一定条件的情况下才能打开这把锁: 在线程1中的加锁使用了lock,所以是不需要条件的,所以顺利的就锁住了,但在unlock的使用了一个整型的条件,它可以开启其它线程中正在等待这把钥匙的临界地,而线程2则需要一把被标识为2的钥匙,所以当线程1循环到最后一次的时候,才最终打开了线程2中的阻塞。但即便如此,NSConditionLock也跟其它的锁一样,是需要lock与unlock对应的,只是lock,lockWhenCondition:与unlock,unlockWithCondition:是可以随意组合的,当然这是与你的需求相关的。 上面代码执行结果如下: 2016-07-23 10:30:00.764 ThreadTest[13645:406942] wait for product 2016-07-23 10:30:00.764 ThreadTest[13645:406951] produce a product, 总量 :1 2016-07-23 10:30:00.765 ThreadTest[13645:406942] custome a product 2016-07-23 10:30:00.765 ThreadTest[13645:406942] wait for product 2016-07-23 10:30:01.767 ThreadTest[13645:406951] produce a product, 总量:1 2016-07-23 10:30:01.767 ThreadTest[13645:406942] custome a product 如果你需要其他功能,源码定义如下:


@interface NSConditionLock : NSObject <NSLocking> {
@private 
    void *_priv;
}
- (instancetype)initWithCondition:(NSInteger)condition NS_DESIGNATED_INITIALIZER;
@property (readonly) NSInteger condition;
- (void)lockWhenCondition:(NSInteger)condition;
- (BOOL)tryLock;
- (BOOL)tryLockWhenCondition:(NSInteger)condition;
- (void)unlockWithCondition:(NSInteger)condition;
- (BOOL)lockBeforeDate:(NSDate *)limit;
- (BOOL)lockWhenCondition:(NSInteger)condition beforeDate:(NSDate *)limit;
@property (nullable, copy) NSString *name NS_AVAILABLE(10_5, 2_0);
@end

NSCondition


NSCondition *condition = [[NSCondition alloc] init]; 
NSMutableArray *products = [NSMutableArray array];
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    while (1) { 
        [condition lock]; 
        if ([products count] == 0) { 
            NSLog(@"wait for product"); 
           [condition wait]; 
       }
      [products removeObjectAtIndex:0];
      NSLog(@"custome a product"); 
      [condition unlock]; 
     } 
}); 

dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{ 
     while (1) { 
         [condition lock]; 
        [products addObject:[[NSObject alloc] init]]; 
        NSLog(@"produce a product,总量:%zi",products.count); 
        [condition signal]; 
        [condition unlock]; 
        sleep(1); 
    } 
});

一种最基本的条件锁。手动控制线程wait和signal。 [condition lock];一般用于多线程同时访问、修改同一个数据源,保证在同一时间内数据源只被访问、修改一次,其他线程的命令需要在lock 外等待,只到unlock ,才可访问[condition unlock];与lock 同时使用[condition wait];让当前线程处于等待状态[condition signal];CPU发信号告诉线程不用在等待,可以继续执行。 上面代码执行结果如下: 2016-07-23 10:37:46.943 ThreadTest[13693:409659] wait for product 2016-07-23 10:37:46.944 ThreadTest[13693:409667] produce a product, 总量 :1 2016-07-23 10:37:46.944 ThreadTest[13693:409659] custome a product 2016-07-23 10:37:46.945 ThreadTest[13693:409659] wait for product 2016-07-23 10:37:47.947 ThreadTest[13693:409667] produce a product, 总量 :1 2016-07-23 10:37:47.947 ThreadTest[13693:409659] custome a product

pthread_mutex

__block pthread_mutex_t theLock; 
pthread_mutex_init(&theLock, NULL);
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{ 
    pthread_mutex_lock(&theLock); 
    NSLog(@"需要线程同步的操作1 开始"); 
    sleep(3); 
    NSLog(@"需要线程同步的操作1 结束"); 
    pthread_mutex_unlock(&theLock); 
}); 

dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{ 
    sleep(1); 
    pthread_mutex_lock(&theLock); 
    NSLog(@"需要线程同步的操作2"); 
    pthread_mutex_unlock(&theLock); 
});

c语言定义下多线程加锁方式。

  1. pthread_mutex_init(pthread_mutex_t  mutex,const pthread_mutexattr_t attr);初始化锁变量mutex。attr为锁属性,NULL值为默认属性。
  2. pthread_mutex_lock(pthread_mutex_t *mutex);加锁
  3. pthread_mutex_tylock(pthread_mutex_t *mutex);加锁,但是与2不一样的是当锁已经在使用的时候,返回为EBUSY,而不是挂起等待。
  4. pthread_mutex_unlock(pthread_mutex_t *mutex);释放锁
  5. pthread_mutex_destroy(pthread_mutex_t *mutex);使用完后释放

代码执行操作结果如下: 2016-07-23 10:45:05.864 ThreadTest[13725:412938] 需要线程同步的操作 1 开始 2016-07-23 10:45:08.867 ThreadTest[13725:412938] 需要线程同步的操作 1 结束 2016-07-23 10:45:08.867 ThreadTest[13725:412931] 需要线程同步的操作 2

pthread_mutex(recursive)


__block pthread_mutex_t theLock; 
//pthread_mutex_init(&theLock, NULL);
pthread_mutexattr_t attr;
pthread_mutexattr_init(&attr); 
pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE); 
pthread_mutex_init(&theLock, &attr); 
pthread_mutexattr_destroy(&attr); 

dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{ 
    static void (^RecursiveMethod)(int); 
    RecursiveMethod = ^(int value) { 
         pthread_mutex_lock(&theLock); 
         if (value > 0) { 
             NSLog(@"value = %d", value); 
             sleep(1); 
             RecursiveMethod(value - 1); 
     }
      pthread_mutex_unlock(&theLock); 
   };
      RecursiveMethod(5); 
});

这是pthread_mutex为了防止在递归的情况下出现死锁而出现的递归锁。作用和NSRecursiveLock递归锁类似。 如果使用pthread_mutex_init(&theLock, NULL);初始化锁的话,上面的代码会出现死锁现象。如果使用递归锁的形式,则没有问题。

OSSpinLock

__block OSSpinLock theLock = OS_SPINLOCK_INIT;
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    OSSpinLockLock(&theLock); 
    NSLog(@"需要线程同步的操作1 开始"); 
    sleep(3); 
    NSLog(@"需要线程同步的操作1 结束");
    OSSpinLockUnlock(&theLock);
});

dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
     OSSpinLockLock(&theLock); 
     sleep(1); 
     NSLog(@"需要线程同步的操作2"); 
     OSSpinLockUnlock(&theLock);
});

OSSpinLock 自旋锁,性能最高的锁。原理很简单,就是一直 do while 忙等。它的缺点是当等待时会消耗大量 CPU 资源,所以它不适用于较长时间的任务。 不过最近YY大神在自己的博客不再安全的 OSSpinLock中说明了OSSpinLock已经不再安全,请大家谨慎使用。

性能对比

对以上各个锁进行1000000次的加锁解锁的空操作时间如下:

方法 1000000消耗时间
OSSpinLock 46.15 ms
dispatch_semaphore 56.50 ms
pthread_mutex 178.28 ms
NSCondition 193.38 ms
NSLock 175.02 ms
pthread_mutex(recursive): 172.56 ms
NSRecursiveLock 157.44 ms
NSConditionLock: 490.04 ms
@synchronized 371.17 ms

总的来说: OSSpinLock和dispatch_semaphore的效率远远高于其他。 @synchronized和NSConditionLock效率较差。 鉴于OSSpinLock的不安全,所以我们在开发中如果考虑性能的话,建议使用dispatch_semaphore。 如果不考虑性能,只是图个方便的话,那就使用@synchronized。 使用NSRecursiveLock,可以避免死锁,同时性能也不错,建议代码中使用。

收藏
1
sina weixin mail 回到顶部