布满式锁的掌握

2015-03-26,1-可以保证在分布式部署的应用集群中,即有两个线程同时访问对数据库进行写的操作,使用@synchronized关键字可以很方便地创建锁对象,也就是多个线程可能会访问同一块资源

马虎车主被锁车外 聪明贵宾犬车内开锁

更新时间:2015-03-26

近日,有热心人士反映一件“奇”事,一位驾驶员不慎将钥匙丢在了自家的轿车内,当时还有两只饲养的贵宾犬在车内,不知所措的车主当即向交警求助,不曾想聪明的贵宾犬竟然在车内自己打开了车锁。究竟是怎么一回事呢?

一名年轻男驾驶员匆匆来到诸永高速杭州方向永嘉服务区高速交警执勤岗亭,向正在执勤的民警求助,称自己在服务区停车吃饭时,不慎将车钥匙落在玛莎拉蒂轿车内,而备用的钥匙也在后备箱,车门现被反锁了,车内还有两只宠物贵宾犬,向民警求助能否联系锁匠帮忙开锁。

接警后,民警随即跟随驾驶员前往查看。在离车较远处,民警便听到车内小狗传来慌张的叫声,在这辆安徽牌照的玛莎拉蒂车旁,车上其他4位乘客正围在边上,焦急地看着车内的两只贵宾犬不知所措,贵宾犬也显得十分焦急,不停地用爪子拍打着车窗。民警近距离观察了下车内车锁的设置,同时也联系服务区内车修店人员前来解锁。当修理厂人员来到车边傻眼了,连连挥手称这车太贵,自己没修过这么贵的车,只能联系4S店人员。

随后驾驶员联系了4S店,4S店人员称修车师傅赶到永嘉服务区需要很长的时间,还要带上专用解锁设备,也不一定能当解当场开。正当驾驶员不知所措,一声犹如天籁般的“滴”开锁声传进了众人的耳蜗,玛莎拉蒂车门居然解锁了。原来是两只贵宾犬趴在车窗上边叫边拍打时,其中一只贵宾犬的前脚不知不觉踩到了车门解锁键,车主与乘客一阵欢呼,打开车门,车主抱着两只狗狗一阵狂亲,称两只小狗好通人性,以后再也不能大意了。

交警提醒:驾驶员停车离开时,千万不能将幼儿、宠物单独留于车内,同时检查是否将车内钥匙带出,贵重物品也尽量随身携带,以免发生意外。

回答什么是分布式锁

前言

一块资源可能会被多个线程共享,也就是多个线程可能会访问同一块资源,比如多个线程访问同一个对象、同一个变量、同一个文件和同一个方法等。因此当多个线程访问同一块资源时,很容易会发生数据错误及数据不安全等问题。因此要避免这些问题,我们需要使用“线程锁”来实现。

下面从以下几个方面来谈谈iOS创建锁的方法:
1、使用关键字
1-1、@synchronized(互斥锁)
优点:使用@synchronized关键字可以很方便地创建锁对象,而且不用显式的创建锁对象。
缺点:会隐式添加一个异常处理来保护代码,该异常处理会在异常抛出的时候自动释放互斥锁。而这种隐式的异常处理会带来系统的额外开销,为优化资源,你可以使用锁对象。

2、GCD-信号量(“互斥锁”)
2-1、dispatch_semaphore

3、 “Object-C”语言
3-1、NSLock(互斥锁)
3-2、NSRecursiveLock(递归锁)
条件锁,递归或循环方法时使用此方法实现锁,可避免死锁等问题。
3-3、NSConditionLock(条件锁)
使用此方法可以指定,只有满足条件的时候才可以解锁。
3-4、NSCondition
3-5、NSDistributedLock(分布式锁)
在IOS中不需要用到,也没有这个方法,因此本文不作介绍,这里写出来只是想让大家知道有这个锁存在。
如果想要学习NSDistributedLock的话,你可以创建MAC
OS的项目自己演练,方法请自行Google,谢谢。

4、C语言
4-1、pthread_mutex(互斥锁)
4-2、pthread_mutex(recursive)(递归锁)
4-3、OSSpinLock
4-4、POSIX(条件锁)

分布式锁相对他的应用场景,即有两个线程同时访问对数据库进行写的操作,这就需要考虑访问的时候我们如何操作.

1、使用关键字

分布式锁实现注意的问题

1-1、@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");
        }
    });

执行结果:
2017-11-22 14:18:19.814511+0800 test[14626:621364]
需要线程同步的操作1 开始
2017-11-22 14:18:22.818111+0800 test[14626:621364]
需要线程同步的操作1 结束
2017-11-22 14:18:22.818334+0800 test[14626:621372]
需要线程同步的操作2

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

1-可以保证在分布式部署的应用集群中,同一个方法在同一时间只能被一台机器上的一个线程执行。

2、GCD-信号量(“互斥锁”)

2-这把锁要是一把可重入锁(避免死锁)

2-1、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);
    });

输出结果:
2017-11-22 18:03:36.546146+0800 test[22770:1324874]
需要线程同步的操作1 开始
2017-11-22 18:03:38.551063+0800 test[22770:1324874]
需要线程同步的操作1 结束
2017-11-22 18:03:38.551440+0800 test[22770:1324870]
需要线程同步的操作2

如果把超时时间设置为<2s的时候,执行的结果就是:

输出结果:
2017-11-22 18:08:07.241971+0800 test[23008:1348365]
需要线程同步的操作1 开始
2017-11-22 18:08:08.246878+0800 test[23008:1348366]
需要线程同步的操作2
2017-11-22 18:08:09.245724+0800 test[23008:1348365]
需要线程同步的操作1 结束

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的话,在线程1还没有执行完成的情况下,此时超时了,将自动执行下面的代码。

这里解释一下什么是重入锁-可重入就意味着:线程可以进入任何一个它已经拥有的锁所同步着的代码块。

3、Object-C语言

场景-线程获得锁的时候宕机-出现了死锁

3-1、使用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(@"超时,没有获得锁");
        }

    });

输出结果
2017-11-22 14:38:37.031007+0800 test[15701:720180]
需要线程同步的操作1 开始
2017-11-22 14:38:38.033012+0800 test[15701:720178] 锁不可用的操作
2017-11-22 14:38:39.035550+0800 test[15701:720180]
需要线程同步的操作1 结束
2017-11-22 14:38:39.036016+0800 test[15701:720178] 没有超时,获得锁

NSLock是Cocoa提供给我们最基本的锁对象,这也是我们经常所使用的,除lock和unlock方法外,NSLock还提供了tryLock和lockBeforeDate:两个方法,前一个方法会尝试加锁,如果锁不可用(已经被锁住),刚并不会阻塞线程,并返回NO。lockBeforeDate:方法会在所指定Date之前尝试加锁,如果在指定时间之前都不能加锁,则返回NO。
注意:锁定(lock)和解锁(unLock)必须配对使用

源码定义如下:

@protocol NSLocking

- (void)lock;
- (void)unlock;

@end

@interface NSLock : NSObject <NSLocking> {
@private
    void *_priv;
}

- (BOOL)tryLock;
- (BOOL)lockBeforeDate:(NSDate *)limit;

@property (nullable, copy) NSString *name NS_AVAILABLE(10_5, 2_0);

@end

可重入锁参考-

3-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实际上定义的是一个递归锁,这个锁可以被同一线程多次请求,而不会引起死锁。这主要是用在循环或递归操作中。

这段代码如果使用注释的NSLock *lock = [[NSLock alloc] init];而不是使用NSRecursiveLock *lock = [[NSRecursiveLock alloc] init];会导致死锁的情况。这是因为在我们的线程中,RecursiveMethod是递归调用的。所以每次进入这个block时,都会去加一次锁,而从第二次开始,由于锁已经被使用了且没有解锁,所以它需要等待锁被解除,这样就导致了死锁,线程被阻塞住了。调试器中会输出如下信息:

输出信息:
2017-11-22 16:32:05.035913+0800 test[18077:901665] value = 5

在这种情况下,我们就可以使用NSRecursiveLock。它可以允许同一线程多次加锁,而不会造成死锁。递归锁会跟踪它被lock的次数。每次成功的lock都必须平衡调用unlock操作。只有所有达到这种平衡,锁最后才能被释放,以供其它线程使用。

如果我们将NSLock代替为NSRecursiveLock,上面代码则会正确执行。

输出结果:
2017-11-22 16:38:52.815599+0800 test[18430:936998] value = 5
2017-11-22 16:38:53.819971+0800 test[18430:936998] value = 4
2017-11-22 16:38:54.821962+0800 test[18430:936998] value = 3
2017-11-22 16:38:55.825592+0800 test[18430:936998] value = 2
2017-11-22 16:38:56.830927+0800 test[18430:936998] value = 1

如果需要其他功能,源码定义如下:

@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

3-这把锁最好是一把阻塞锁(根据业务需求考虑要不要这条)

3-3、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];
        }

    });

输出结果:
2017-11-22 16:49:34.453331+0800 test[18984:990063] wait for
product
2017-11-22 16:49:34.453351+0800 test[18984:990053] produce a
product,总量:1
2017-11-22 16:49:34.453596+0800 test[18984:990063] custome a
product
2017-11-22 16:49:34.453757+0800 test[18984:990063] wait for
product
2017-11-22 16:49:35.458634+0800 test[18984:990053] produce a
product,总量:1
2017-11-22 16:49:35.458813+0800 test[18984:990063] custome a product

当我们在使用多线程的时候,有时一把只会lock和unlock的锁未必就能完全满足我们的使用。因为普通的锁只能关心锁与不锁,而不在乎用什么钥匙才能开锁,而我们在处理资源共享的时候,多数情况是只有满足一定条件的情况下才能打开这把锁:

在线程1中的加锁使用了lock,所以是不需要条件的,所以顺利的就锁住了,但在unlock的使用了一个整型的条件,它可以开启其它线程中正在等待这把钥匙的临界地,而线程2则需要一把被标识为2的钥匙,所以当线程1循环到最后一次的时候,才最终打开了线程2中的阻塞。但即便如此,NSConditionLock也跟其它的锁一样,是需要lock与unlock对应的,只是lock,lockWhenCondition:与unlock,unlockWithCondition:是可以随意组合的,当然这是与你的需求相关的。

如果你需要其他功能,源码定义如下:

@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

理想的情况则是;
在线程竞争不激烈的情况下,使用自旋锁也是可重入锁,竞争激烈的情况下使用,阻塞锁。

3-4、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);
        }

    });

输出结果:
2017-11-22 16:57:25.111774+0800 test[19391:1035560] wait for
product
2017-11-22 16:57:25.112058+0800 test[19391:1035559] produce a
product,总量:1
2017-11-22 16:57:25.112214+0800 test[19391:1035560] custome a
product
2017-11-22 16:57:25.113221+0800 test[19391:1035560] wait for
product
2017-11-22 16:57:26.117182+0800 test[19391:1035559] produce a
product,总量:1
2017-11-22 16:57:26.117525+0800 test[19391:1035560] custome a
product

因为阻塞锁不会占用CPU资源

4、C语言

4-有高可用的获取锁和释放锁功能

4-1、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);

    });

输出结果:
2017-11-22 17:38:29.917021+0800 test[21499:1202815]
需要线程同步的操作1 开始
2017-11-22 17:38:32.920006+0800 test[21499:1202815]
需要线程同步的操作1 结束
2017-11-22 17:38:32.920364+0800 test[21499:1202812]
需要线程同步的操作2

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);使用完后释放

5-获取锁和释放锁的性能要好

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