iOS- 多线程中如何去保证线程安全

时间  2019-12-15
标签 ios 多线程 何去 保证 线程 安全 栏目 iOS 繁體版
原文   原文链接

1、前言　　

前段时间看了几个开源项目，发现他们保持线程同步的方式各不相同，有@synchronized、NSLock、dispatch_semaphore、NSCondition、pthread_mutex、OSSpinLock。后来网上查了一下，发现他们的实现机制各不相同，性能也各不同。git

很差意思，咱们日常使用最多的@synchronized是性能最差的。github

 

2、介绍与使用

2.一、@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-06-29 20:48:35.747 SafeMultiThread[35945:580107] 须要线程同步的操做1 开始
2016-06-29 20:48:38.748 SafeMultiThread[35945:580107] 须要线程同步的操做1 结束
2016-06-29 20:48:38.749 SafeMultiThread[35945:580118] 须要线程同步的操做2async

 

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);spa

传入的参数为long，输出一个dispatch_semaphore_t类型且值为value的信号量。线程

值得注意的是，这里的传入的参数value必须大于或等于0，不然dispatch_semaphore_create会返回NULL。debug

（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

上面代码的执行结果为：

2016-06-29 20:47:52.324 SafeMultiThread[35945:579032] 须要线程同步的操做1 开始
2016-06-29 20:47:55.325 SafeMultiThread[35945:579032] 须要线程同步的操做1 结束
2016-06-29 20:47:55.326 SafeMultiThread[35945:579033] 须要线程同步的操做2

若是把超时时间设置为

2016-06-30 18:53:24.049 SafeMultiThread[30834:434334] 须要线程同步的操做1 开始
2016-06-30 18:53:25.554 SafeMultiThread[30834:434332] 须要线程同步的操做2
2016-06-30 18:53:26.054 SafeMultiThread[30834:434334] 须要线程同步的操做1 结束

 

2.三、NSLock　　

    NSLock *lock = [[NSLock alloc] init];
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        //[lock lock];
        [lock lockBeforeDate:[NSDate date]];
            NSLog(@"须要线程同步的操做1 开始");
            sleep(2);
            NSLog(@"须要线程同步的操做1 结束");
        [lock unlock];

    });

    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        sleep(1);
        if ([lock tryLock]) {//尝试获取锁，若是获取不到返回NO，不会阻塞该线程
            NSLog(@"锁可用的操做");
            [lock unlock];
        }else{
            NSLog(@"锁不可用的操做");
        }

        NSDate *date = [[NSDate alloc] initWithTimeIntervalSinceNow:3];
        if ([lock lockBeforeDate:date]) {//尝试在将来的3s内获取锁，并阻塞该线程，若是3s内获取不到恢复线程, 返回NO,不会阻塞该线程
            NSLog(@"没有超时，得到锁");
            [lock unlock];
        }else{
            NSLog(@"超时，没有得到锁");
        }

    });

 

SLock是Cocoa提供给咱们最基本的锁对象，这也是咱们常常所使用的，除lock和unlock方法外，NSLock还提供了tryLock和lockBeforeDate:两个方法，前一个方法会尝试加锁，若是锁不可用(已经被锁住)，刚并不会阻塞线程，并返回NO。lockBeforeDate:方法会在所指定Date以前尝试加锁，若是在指定时间以前都不能加锁，则返回NO。

上面代码的执行结果为：

2016-06-29 20:45:08.864 SafeMultiThread[35911:575795] 须要线程同步的操做1 开始
2016-06-29 20:45:09.869 SafeMultiThread[35911:575781] 锁不可用的操做
2016-06-29 20:45:10.869 SafeMultiThread[35911:575795] 须要线程同步的操做1 结束
2016-06-29 20:45:10.870 SafeMultiThread[35911:575781] 没有超时，得到锁

 

2.四、NSRecursiveLock递归锁　　

    //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);
    });

 

NSRecursiveLock实际上定义的是一个递归锁，这个锁能够被同一线程屡次请求，而不会引发死锁。这主要是用在循环或递归操做中。

这段代码是一个典型的死锁状况。在咱们的线程中，RecursiveMethod是递归调用的。因此每次进入这个block时，都会去加一次锁，而从第二次开始，因为锁已经被使用了且没有解锁，因此它须要等待锁被解除，这样就致使了死锁，线程被阻塞住了。调试器中会输出以下信息：

2016-06-30 19:08:06.393 SafeMultiThread[30928:449008] value = 5
2016-06-30 19:08:07.399 SafeMultiThread[30928:449008] -[NSLock lock]: deadlock ( ‘(null)’)
2016-06-30 19:08:07.399 SafeMultiThread[30928:449008] Break on _NSLockError() to debug.

在这种状况下，咱们就可使用NSRecursiveLock。它能够容许同一线程屡次加锁，而不会形成死锁。递归锁会跟踪它被lock的次数。每次成功的lock都必须平衡调用unlock操做。只有全部达到这种平衡，锁最后才能被释放，以供其它线程使用。

若是咱们将NSLock代替为NSRecursiveLock，上面代码则会正确执行。

2016-06-30 19:09:41.414 SafeMultiThread[30949:450684] value = 5
2016-06-30 19:09:42.418 SafeMultiThread[30949:450684] value = 4
2016-06-30 19:09:43.419 SafeMultiThread[30949:450684] value = 3
2016-06-30 19:09:44.424 SafeMultiThread[30949:450684] value = 2
2016-06-30 19:09:45.426 SafeMultiThread[30949:450684] value = 1

 

2.五、NSConditionLock条件锁　　

    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-06-30 20:31:58.699 SafeMultiThread[31282:521698] wait for product
2016-06-30 20:31:58.699 SafeMultiThread[31282:521708] produce a product,总量:1
2016-06-30 20:31:58.700 SafeMultiThread[31282:521698] custome a product
2016-06-30 20:31:58.700 SafeMultiThread[31282:521698] wait for product
2016-06-30 20:31:59.705 SafeMultiThread[31282:521708] produce a product,总量:1
2016-06-30 20:31:59.706 SafeMultiThread[31282:521698] custome a product
2016-06-30 20:31:59.706 SafeMultiThread[31282:521698] wait for product
2016-06-30 20:32:00.707 SafeMultiThread[31282:521708] produce a product,总量:1
2016-06-30 20:32:00.708 SafeMultiThread[31282:521698] custome a product

2.六、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-06-30 20:21:25.295 SafeMultiThread[31256:513991] wait for product
2016-06-30 20:21:25.296 SafeMultiThread[31256:513994] produce a product,总量:1
2016-06-30 20:21:25.296 SafeMultiThread[31256:513991] custome a product
2016-06-30 20:21:25.297 SafeMultiThread[31256:513991] wait for product
2016-06-30 20:21:26.302 SafeMultiThread[31256:513994] produce a product,总量:1
2016-06-30 20:21:26.302 SafeMultiThread[31256:513991] custome a product
2016-06-30 20:21:26.302 SafeMultiThread[31256:513991] wait for product
2016-06-30 20:21:27.307 SafeMultiThread[31256:513994] produce a product,总量:1
2016-06-30 20:21:27.308 SafeMultiThread[31256:513991] custome a product

 

2.七、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-06-30 21:13:32.440 SafeMultiThread[31429:548869] 须要线程同步的操做1 开始
2016-06-30 21:13:35.445 SafeMultiThread[31429:548869] 须要线程同步的操做1 结束
2016-06-30 21:13:35.446 SafeMultiThread[31429:548866] 须要线程同步的操做2

 

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(&lock, &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);初始化锁的话，上面的代码会出现死锁现象。若是使用递归锁的形式，则没有问题。

 

2.九、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 资源，因此它不适用于较长时间的任务。 OSSpinLock已经再也不安全，请你们谨慎使用。

3、性能对比　　

对以上各个锁进行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。

 

做者： 景铭巴巴

本文版权归做者和博客园共有，欢迎转载，但必须保留此段声明，且在文章页面明显位置给出原文链接。清澈Saup.

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程