分布式锁的实现

思路一：SQL优化

为了具体模拟秒杀这一场景，假设库存表叫做stock，商品数量叫做num，有业务代码计算出的新数目为new_num=num-1，原来执行的SQL为：

update stock set num=new_num where id = id=#{id};

我们可以改进SQL，让数据库根据自己当前的值更新数据，比如写成下面这样：

update stock set num=num-1 where id = #{id};
复制代码

这样虽然看似解决了问题，但是假设此时库存的数量为1，两个线程各自减1后，会发现库存被扣成了-1，同样也无法完全解决并发问题。

思路二：代码加锁

既然两个线程同时拿数据还是有问题，那么有没有办法让它们依次执行，于是很容易想到在查库存之前先加上锁，比如Java的synchronized关键字。

这能很好的保证串行，保证每次只有一个线程去执行查库存和扣库存的代码段，但同样缺点也非常多：

无法做到细粒度的控制，如果有的人秒杀商品A、有的秒杀商品B，都要走秒杀方法，相互之间不冲突但是也只能串行执行，访问会变得很慢。
因为spring里的@service是单例的，所以可以这么写，如果用python语言的django框架，则没法在代码层做类似的控制，不通用。
只支持单点（单机、服务器环境），无法做到水平扩展，现在基本都是集群部署的，仅能一台机器生效。

也许，我们需要一种第三方的机制，去实现这样的一把锁。

思路三：基于MySQL的悲观锁

因为所有的线程都在访问同一张表，可以在数据库上加锁，典型的做法有悲观锁和乐观锁两种。

悲观锁利用了select...for update 语法，例如：

select * from stock where id=#{id} for update;

注意：使用悲观锁要把业务代码放在事务里。

悲观锁获取数据时对数据行了锁定，其他事务要想获取锁，必须等原事务结束。

使用selec...for update会把数据给锁住，MySQL InnoDB默认Row-Level Lock，所以只有「明确」地指定主键，MySQL 才会执行Row lock (只锁住被选取的数据) ，否则MySQL 将会执行Table Lock (将整个数据表单给锁住)。

使用悲观锁的缺点是，因为要锁表，所以并发性不高，如果并发过高，数据库压力过大，会宕机。

思路四：基于MySQL的乐观锁

乐观锁相对悲观锁而言，乐观锁假设认为数据一般情况下不会造成冲突，所以在数据进行提交更新的时候，才会正式对数据的冲突与否进行检测，如果发现冲突了，则让返回用户错误的信息，让用户决定如何去做。

乐观锁的实现有两种方法。

使用版本号实现乐观锁

版本号的实现方式有两种，一个是数据版本机制，一个是时间戳机制。具体如下。

使用数据版本（Version）记录机制实现，这是乐观锁最常用的一种实现方式。何谓数据版本？即为数据增加一个版本标识，一般是通过为数据库表增加一个数字类型的 version 字段来实现。当读取数据时，将version字段的值一同读出，数据每更新一次，对此version值加一。当我们提交更新的时候，判断数据库表对应记录的当前版本信息与第一次取出来的version值进行比对，如果数据库表当前版本号与第一次取出来的version值相等，则予以更新，否则认为是过期数据。

如果使用乐观锁的话，扣库存的SQL变化为下：

1.查询出商品信息

select num,version from stock where id=#{id};

扣减数目。new_num = num -1
修改数据库。

update stock set num=new_num, version=version+1 where id=#{id} and version=#{version};

如果此时的version已经变化了，则会更新失败，可以根据具体业务采取重试或者报错。

使用条件限制实现乐观锁

这个适用于只更新是做数据安全校验，适合库存模型，扣份额和回滚份额，性能更高，十分方便实用。

SQL改为：

update stock SET num = num - #{buyNum} where id = #{id} and num - #{buyNum} >= 0;

注意：乐观锁的更新操作，最好用主键或者唯一索引来更新，这样是行锁，否则更新时会锁表。

乐观锁在扛并发能力上比悲观锁要高，应用会更多一些。但是当并发越来越高的话，对数据库压力也会比较大，因为如果更新失败去重试，可能会不断地去查询数据库。

思路五：基于Redis分布式锁

既然数据库的锁实现永远绕不开并发问题，我们就求助于第三方中间件，比如Redis。

这里提一下，如果在并发不高的情况下，基于MySQL的悲观锁或乐观锁能解决问题，而且维护起来比较简单，不需要引入额外的组件，系统可用性高。所谓做架构，其实就是在做trade-off。

简单讲下实现原理，线程A先在Redis里设置该商品的key（比如goods_1）为1，如果线程B也查到1，则不但轮询，直到线程A释放掉这把锁，线程B才能再拿到这把锁。

我这里用Python语言简单模拟了实现一下，用了redis-py的库，写了一个Lock类，里面包含两个方法，获取锁acquire和释放锁release：

import redis
class Lock:
    def __init__(self, name):
        self.redis_client = redis.Redis(host="127.0.0.1")
        self.name = name

    def acquire(self):
        # 如果为空或者为None那么代表获取到锁
        if not self.redis_client.get(self.name):
            self.redis_client.set(self.name, 1) 
            return True
        else:
            # 如果不想阻塞住轮询获取锁，可以直接返回False
            while True:
                import time
                time.sleep(1)
                if self.redis_client.get(self.name):
                    return True

    def release(self):
        self.redis_client.delete(self.name)

思路六：Redis分布式锁的问题和改进

确保原子性

有经验的小伙伴一定会发现我上面代码的问题，当并发非常高时，可能多个线程同时进入到 if not self.redis_client.get(self.name)，于是同时获取到了锁，这就使得分布式锁失效了。

所以我们要保证在读取和设置值这两步的原子性。

如何解决呢？Redis天然提供了setnx命令，可以保证原子操作，命令在指定的key不存在时，为key设置指定的值。

于是我们可以把上面的Lock代码升级为如下：

import redis
class Lock:
    def __init__(self, name):
        self.redis_client = redis.Redis(host="127.0.0.1")
        self.name = name

    def acquire(self):
        if self.redis_client.setnx(self.name, 1): # 如果不存在设置并且返回1，否在返回0， 这是原子操作
            return True
        else:
            # 如果不想阻塞住轮询获取锁，可以直接返回False
            while True:
                import time
                time.sleep(1)
                if self.redis_client.setnx(self.name, 1): # 注意这个地方也要改
                    return True

    def release(self):
        self.redis_client.delete(self.name)

锁的过期时间

我们继续往下思考，假如一个线程拿到了锁，但是由于某些原因（比如网络连不上redis，代码异常，突然断电）并未释放锁，导致其他线程都拿不到锁，处于永远等待的状态，造成死锁。

比较好的解决办法就是设置给锁设置过期时间，我们利用redis-py库提供的set函数，并给加上原子操作和过期参数。

self.redis_client.set(self.name, self.id, nx=True, ex=15)

锁的续租

但是，过期设置会产生新的问题：

如果当前的线程如果在一段时间后没有执行完，然后key过期了，会导致另一个线程拿到锁也会继续执行，程序不安全。

另外，另一个线程有可能先执行完，会将当前锁给释放掉，释放掉了本属于原来的线程的锁。

所以，如果当前的线程没有执行完，那它还应该在适当的时候去续租，将过期时间重新设置。

比较经验性的做法是，比如过期时间是15s，那就在15s的2/3的时候去续租，也就是运行10s以后去将过期时间重新设置为15s。可以在程序里启动一个新的线程去完成去定时的完成这个续租的过程。

删除锁的安全性

前面还提到了一点，别的线程有把当前线程的锁给释放掉的风险。

我们可以给获取锁设置值的时候，不用1，而用uuid，并在释放的时候判断是否为当前线程的uuid，防止被其他线程给释放掉。

于是分布式锁的代码现在进化成了下面这样：

import uuid
import redis
class Lock:
    def __init__(self, name, id=None):
        self.id = uuid.uuid4()
        self.redis_client = redis.Redis(host="192.168.0.104")
        self.name = name

    def acquire(self):
        # 设置过期时间15s, 如果不存在设置并且返回1，否在返回0， 这是原子操作
        if self.redis_client.set(self.name, self.id, nx=True, ex=15): 
            # 启动一个线程然后去定时的刷新这个过期 这个操作最好也是使用lua脚本来完成
            return True
        else:
            while True:
                import time
                time.sleep(1)
                if self.redis_client.set(self.name, self.id, nx=True, ex=15):
                    return True

    def release(self):
        # 先做一个判断，先取出值来然后判断当前的值和你自己的lock中的id是否一致，如果一致删除，如果不一致报错
        # 这块代码不安全， 将get和delete操作原子化，但是Redis可以使用lua脚本去完成这个操作使得该操作原子化
        id = self.redis_client.get(self.name)
        if id == self.id:
            self.redis_client.delete(self.name)
        else:
            print("不能删除不属于自己的锁")

我上面的代码并不完整，因为想要get和delete操作原子化，Redis并没有相关操作指令，仍然会出现安全问题，同样在续租的过程里也会有这样的问题。

但是，Redis 为这样的用户场景提供了 lua 脚本支持，用户可以向服务器发送 lua 脚本来执行自定义动作，获取脚本的响应数据。Redis 服务器会单线程原子性执行 lua 脚本，保证 lua 脚本在处理的过程中不会被任意其它请求打断。

总结Redis分布式锁

至此，我们总结一下分布式锁需要解决的问题：

互斥性：任意时刻只能有一个客户端拥有锁，不能同时多个客户端获取
死锁：获取锁的客户端因为某些原因而宕机，而未能释放锁，其他客户端无法获取此锁，需要有机制来避免该类问题的发生

比如代码异常，导致无法运行到release
当前服务器网络出问题，比如该release时，突然访问不了Redis了
服务器断电

安全性：锁只能被持有该锁的用户删除，而不能被其他用户删除
容错：当部分节点宕机，客户端仍能获取锁或者释放锁

思路七：Python第三方的开源库

前面提到了需要用Lua脚本解决安全问题，但是lua脚本写起来比较麻烦，这里我推荐网络上一个第三方的开源库，有非常完整的Python实现Redis的分布式锁的方法。

我在这里贴一下这个库的流程图：

这个库的总体实现还是跟我们前面讲的一致，但是有些细节上的差别。通过阅读源码，我总结如下：

为了减少无意义的轮询，会另外建一个Redis的列表，使用了Redis的blpop指令，移出并获取列表的第一个元素，如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止。
续租那里比较难读懂，简单来讲，它会启动一个线程去做续租，假设锁的时间是15s，续租检查的间隔就是15s的2/3，即10s，续租做的事情，就是重新设置锁的超时为15s，并且在10s后继续进行检查。
如果业务代码产生阻塞，续租时可能造成代码无限等待，需要慎用，所以该库提供了可选参数。
使用了__enter__,__exit__魔术方法，客户端调用时支持with实现。

至此，Redis锁的分布式锁部分已经全部介绍完了，它的优点是使用简单，同时性能高，而且Redis也是非常常用的组件，不需要额外去维护。

此外，由于单机Redis也有挂掉的风险，我们在生产上会使用Redis cluster或Redis sentinel保证高可用。

思路八：基于zookeeper的分布式锁

除了使用Redis实现，zookeeper也可以实现分布式锁。但是如果项目中并未用到zookeeper，我觉得没必要引入额外的组件，对这种方式，我就不多做介绍了。

思路九：Java中的Redission

如果是Java代码，可以使用Redission包来实现分布式锁。

示例代码如下：

// 1.构造redisson实现分布式锁必要的Config
Config config = new Config();
config.useSingleServer().setAddress("redis://127.0.0.1:5379").setPassword("123456").setDatabase(0);
// 2.构造RedissonClient
RedissonClient redissonClient = Redisson.create(config);
// 3.获取锁对象实例（无法保证是按线程的顺序获取到）
RLock rLock = redissonClient.getLock(lockKey);
try {
    /**
     * 4.尝试获取锁
     * waitTimeout 尝试获取锁的最大等待时间，超过这个值，则认为获取锁失败
     * leaseTime   锁的持有时间,超过这个时间锁会自动失效（值应设置为大于业务处理的时间，确保在锁有效期内业务能处理完）
     */
    boolean res = rLock.tryLock((long)waitTimeout, (long)leaseTime, TimeUnit.SECONDS);
    if (res) {
        //成功获得锁，在这里处理业务
    }
} catch (Exception e) {
    throw new RuntimeException("aquire lock fail");
}finally{
    //无论如何, 最后都要解锁
    rLock.unlock();
}

后续规划

--------------------------------------------------

在整个系统提供一个全局、唯一的获取锁的“东西”，然后每个系统在需要加锁时，都去问这个“东西”拿到一把锁，这样不同的系统拿到的就可以认为是同一把锁。

可以是Redis、Zookeeper，也可以是数据库。

基于Redis实现分布式锁

上面分析为啥要使用分布式锁了，这里我们来具体看看分布式锁落地的时候应该怎么样处理。扩展：Redisson是如何实现分布式锁的？

最常见的一种方案就是使用Redis做分布式锁

使用Redis做分布式锁的思路大概是这样的：在redis中设置一个值表示加了锁，然后释放锁的时候就把这个key删除。

具体代码是这样的：

// 获取锁
// NX是指如果key不存在就成功，key存在返回false，PX可以指定过期时间
SET anyLock unique_value NX PX 30000
 
 
// 释放锁：通过执行一段lua脚本
// 释放锁涉及到两条指令，这两条指令不是原子性的
// 需要用到redis的lua脚本支持特性，redis执行lua脚本是原子性的
if redis.call("get",KEYS[1]) == ARGV[1] then
return redis.call("del",KEYS[1])
else
return 0
end

这种方式有几大要点：

一定要用SET key value NX PX milliseconds 命令

如果不用，先设置了值，再设置过期时间，这个不是原子性操作，有可能在设置过期时间之前宕机，会造成死锁(key永久存在)
value要具有唯一性

这个是为了在解锁的时候，需要验证value是和加锁的一致才删除key。

这是避免了一种情况：假设A获取了锁，过期时间30s，此时35s之后，锁已经自动释放了，A去释放锁，但是此时可能B获取了锁。A客户端就不能删除B的锁了。

除了要考虑客户端要怎么实现分布式锁之外，还需要考虑redis的部署问题。

redis有3种部署方式：

单机模式
master-slave + sentinel选举模式
redis cluster模式

使用redis做分布式锁的缺点在于：如果采用单机部署模式，会存在单点问题，只要redis故障了。加锁就不行了。

采用master-slave模式，加锁的时候只对一个节点加锁，即便通过sentinel做了高可用，但是如果master节点故障了，发生主从切换，此时就会有可能出现锁丢失的问题。

基于以上的考虑，其实redis的作者也考虑到这个问题，他提出了一个RedLock的算法，这个算法的意思大概是这样的：

假设redis的部署模式是redis cluster，总共有5个master节点，通过以下步骤获取一把锁：

获取当前时间戳，单位是毫秒
轮流尝试在每个master节点上创建锁，过期时间设置较短，一般就几十毫秒
尝试在大多数节点上建立一个锁，比如5个节点就要求是3个节点（n / 2 +1）
客户端计算建立好锁的时间，如果建立锁的时间小于超时时间，就算建立成功了
要是锁建立失败了，那么就依次删除这个锁
只要别人建立了一把分布式锁，你就得不断轮询去尝试获取锁

但是这样的这种算法还是颇具争议的，可能还会存在不少的问题，无法保证加锁的过程一定正确。

另一种方式：Redisson

此外，实现Redis的分布式锁，除了自己基于redis client原生api来实现之外，还可以使用开源框架：Redission

Redisson是一个企业级的开源Redis Client，也提供了分布式锁的支持。我也非常推荐大家使用，为什么呢？

回想一下上面说的，如果自己写代码来通过redis设置一个值，是通过下面这个命令设置的。

SET anyLock unique_value NX PX 30000

这里设置的超时时间是30s，假如我超过30s都还没有完成业务逻辑的情况下，key会过期，其他线程有可能会获取到锁。

这样一来的话，第一个线程还没执行完业务逻辑，第二个线程进来了也会出现线程安全问题。所以我们还需要额外的去维护这个过期时间，太麻烦了~

我们来看看redisson是怎么实现的？先感受一下使用redission的爽：

Config config = new Config();
config.useClusterServers()
.addNodeAddress("redis://192.168.31.101:7001")
.addNodeAddress("redis://192.168.31.101:7002")
.addNodeAddress("redis://192.168.31.101:7003")
.addNodeAddress("redis://192.168.31.102:7001")
.addNodeAddress("redis://192.168.31.102:7002")
.addNodeAddress("redis://192.168.31.102:7003");
 
RedissonClient redisson = Redisson.create(config);
 
 
RLock lock = redisson.getLock("anyLock");
lock.lock();
lock.unlock();

就是这么简单，我们只需要通过它的api中的lock和unlock即可完成分布式锁，他帮我们考虑了很多细节：

redisson所有指令都通过lua脚本执行，redis支持lua脚本原子性执行
redisson设置一个key的默认过期时间为30s,如果某个客户端持有一个锁超过了30s怎么办？

redisson中有一个watchdog的概念，翻译过来就是看门狗，它会在你获取锁之后，每隔10秒帮你把key的超时时间设为30s

这样的话，就算一直持有锁也不会出现key过期了，其他线程获取到锁的问题了。
redisson的“看门狗”逻辑保证了没有死锁发生。

(如果机器宕机了，看门狗也就没了。此时就不会延长key的过期时间，到了30s之后就会自动过期了，其他线程可以获取到锁)

这里稍微贴出来其实现代码：

// 加锁逻辑
private <T> RFuture<Long> tryAcquireAsync(long leaseTime, TimeUnit unit, final long threadId) {
    if (leaseTime != -1) {
        return tryLockInnerAsync(leaseTime, unit, threadId, RedisCommands.EVAL_LONG);
    }
    // 调用一段lua脚本，设置一些key、过期时间
    RFuture<Long> ttlRemainingFuture = tryLockInnerAsync(commandExecutor.getConnectionManager().getCfg().getLockWatchdogTimeout(), TimeUnit.MILLISECONDS, threadId, RedisCommands.EVAL_LONG);
    ttlRemainingFuture.addListener(new FutureListener<Long>() {
        @Override
        public void operationComplete(Future<Long> future) throws Exception {
            if (!future.isSuccess()) {
                return;
            }
 
            Long ttlRemaining = future.getNow();
            // lock acquired
            if (ttlRemaining == null) {
                // 看门狗逻辑
                scheduleExpirationRenewal(threadId);
            }
        }
    });
    return ttlRemainingFuture;
}
 
 
<T> RFuture<T> tryLockInnerAsync(long leaseTime, TimeUnit unit, long threadId, RedisStrictCommand<T> command) {
    internalLockLeaseTime = unit.toMillis(leaseTime);
 
    return commandExecutor.evalWriteAsync(getName(), LongCodec.INSTANCE, command,
              "if (redis.call('exists', KEYS[1]) == 0) then " +
                  "redis.call('hset', KEYS[1], ARGV[2], 1); " +
                  "redis.call('pexpire', KEYS[1], ARGV[1]); " +
                  "return nil; " +
              "end; " +
              "if (redis.call('hexists', KEYS[1], ARGV[2]) == 1) then " +
                  "redis.call('hincrby', KEYS[1], ARGV[2], 1); " +
                  "redis.call('pexpire', KEYS[1], ARGV[1]); " +
                  "return nil; " +
              "end; " +
              "return redis.call('pttl', KEYS[1]);",
                Collections.<Object>singletonList(getName()), internalLockLeaseTime, getLockName(threadId));
}
 
 
 
// 看门狗最终会调用了这里
private void scheduleExpirationRenewal(final long threadId) {
    if (expirationRenewalMap.containsKey(getEntryName())) {
        return;
    }
 
    // 这个任务会延迟10s执行
    Timeout task = commandExecutor.getConnectionManager().newTimeout(new TimerTask() {
        @Override
        public void run(Timeout timeout) throws Exception {
 
            // 这个操作会将key的过期时间重新设置为30s
            RFuture<Boolean> future = renewExpirationAsync(threadId);
 
            future.addListener(new FutureListener<Boolean>() {
                @Override
                public void operationComplete(Future<Boolean> future) throws Exception {
                    expirationRenewalMap.remove(getEntryName());
                    if (!future.isSuccess()) {
                        log.error("Can't update lock " + getName() + " expiration", future.cause());
                        return;
                    }
 
                    if (future.getNow()) {
                        // reschedule itself
                        // 通过递归调用本方法，无限循环延长过期时间
                        scheduleExpirationRenewal(threadId);
                    }
                }
            });
        }
 
    }, internalLockLeaseTime / 3, TimeUnit.MILLISECONDS);
 
    if (expirationRenewalMap.putIfAbsent(getEntryName(), new ExpirationEntry(threadId, task)) != null) {
        task.cancel();
    }
}

另外，redisson还提供了对redlock算法的支持,
它的用法也很简单：
RedissonClient redisson = Redisson.create(config);
RLock lock1 = redisson.getFairLock("lock1");
RLock lock2 = redisson.getFairLock("lock2");
RLock lock3 = redisson.getFairLock("lock3");
RedissonRedLock multiLock = new RedissonRedLock(lock1, lock2, lock3);
multiLock.lock();
multiLock.unlock();
小结：
本节分析了使用redis作为分布式锁的具体落地方案
以及其一些局限性
然后介绍了一个redis的客户端框架redisson，
这也是我推荐大家使用的，

基于zookeeper实现分布式锁

常见的分布式锁实现方案里面，除了使用redis来实现之外，使用zookeeper也可以实现分布式锁。

在介绍zookeeper(下文用zk代替)实现分布式锁的机制之前，先粗略介绍一下zk是什么东西：

Zookeeper是一种提供配置管理、分布式协同以及命名的中心化服务。

zk的模型是这样的：zk包含一系列的节点，叫做znode，就好像文件系统一样每个znode表示一个目录，然后znode有一些特性：

有序节点：假如当前有一个父节点为/lock，我们可以在这个父节点下面创建子节点；

zookeeper提供了一个可选的有序特性，例如我们可以创建子节点“/lock/node-”并且指明有序，那么zookeeper在生成子节点时会根据当前的子节点数量自动添加整数序号

也就是说，如果是第一个创建的子节点，那么生成的子节点为/lock/node-0000000000，下一个节点则为/lock/node-0000000001，依次类推。
临时节点：客户端可以建立一个临时节点，在会话结束或者会话超时后，zookeeper会自动删除该节点。
事件监听：在读取数据时，我们可以同时对节点设置事件监听，当节点数据或结构变化时，zookeeper会通知客户端。当前zookeeper有如下四种事件：

- 节点创建
- 节点删除
- 节点数据修改
- 子节点变更

基于以上的一些zk的特性，我们很容易得出使用zk实现分布式锁的落地方案：

使用zk的临时节点和有序节点，每个线程获取锁就是在zk创建一个临时有序的节点，比如在/lock/目录下。
创建节点成功后，获取/lock目录下的所有临时节点，再判断当前线程创建的节点是否是所有的节点的序号最小的节点
如果当前线程创建的节点是所有节点序号最小的节点，则认为获取锁成功。
如果当前线程创建的节点不是所有节点序号最小的节点，则对节点序号的前一个节点添加一个事件监听。

比如当前线程获取到的节点序号为/lock/003,然后所有的节点列表为[/lock/001,/lock/002,/lock/003],则对/lock/002这个节点添加一个事件监听器。

如果锁释放了，会唤醒下一个序号的节点，然后重新执行第3步，判断是否自己的节点序号是最小。

比如/lock/001释放了，/lock/002监听到时间，此时节点集合为[/lock/002,/lock/003],则/lock/002为最小序号节点，获取到锁。

整个过程如下：

具体的实现思路就是这样，至于代码怎么写，这里比较复杂就不贴出来了。

Curator介绍

Curator是一个zookeeper的开源客户端，也提供了分布式锁的实现。

他的使用方式也比较简单：

InterProcessMutex interProcessMutex = new InterProcessMutex(client,"/anyLock");
interProcessMutex.acquire();
interProcessMutex.release();

其实现分布式锁的核心源码如下：

private boolean internalLockLoop(long startMillis, Long millisToWait, String ourPath) throws Exception
{
    boolean  haveTheLock = false;
    boolean  doDelete = false;
    try {
        if ( revocable.get() != null ) {
            client.getData().usingWatcher(revocableWatcher).forPath(ourPath);
        }
 
        while ( (client.getState() == CuratorFrameworkState.STARTED) && !haveTheLock ) {
            // 获取当前所有节点排序后的集合
            List<String>        children = getSortedChildren();
            // 获取当前节点的名称
            String              sequenceNodeName = ourPath.substring(basePath.length() + 1); // +1 to include the slash
            // 判断当前节点是否是最小的节点
            PredicateResults    predicateResults = driver.getsTheLock(client, children, sequenceNodeName, maxLeases);
            if ( predicateResults.getsTheLock() ) {
                // 获取到锁
                haveTheLock = true;
            } else {
                // 没获取到锁，对当前节点的上一个节点注册一个监听器
                String  previousSequencePath = basePath + "/" + predicateResults.getPathToWatch();
                synchronized(this){
                    Stat stat = client.checkExists().usingWatcher(watcher).forPath(previousSequencePath);
                    if ( stat != null ){
                        if ( millisToWait != null ){
                            millisToWait -= (System.currentTimeMillis() - startMillis);
                            startMillis = System.currentTimeMillis();
                            if ( millisToWait <= 0 ){
                                doDelete = true;    // timed out - delete our node
                                break;
                            }
                            wait(millisToWait);
                        }else{
                            wait();
                        }
                    }
                }
                // else it may have been deleted (i.e. lock released). Try to acquire again
            }
        }
    }
    catch ( Exception e ) {
        doDelete = true;
        throw e;
    } finally{
        if ( doDelete ){
            deleteOurPath(ourPath);
        }
    }
    return haveTheLock;
}

其实curator实现分布式锁的底层原理和上面分析的是差不多的。这里我们用一张图详细描述其原理：

两种方案的优缺点比较

学完了两种分布式锁的实现方案之后，本节需要讨论的是redis和zk的实现方案中各自的优缺点。

对于redis的分布式锁而言，它有以下缺点：

它获取锁的方式简单粗暴，获取不到锁直接不断尝试获取锁，比较消耗性能。
另外来说的话，redis的设计定位决定了它的数据并不是强一致性的，在某些极端情况下，可能会出现问题。锁的模型不够健壮
即便使用redlock算法来实现，在某些复杂场景下，也无法保证其实现100%没有问题，关于redlock的讨论可以看How to do distributed locking
redis分布式锁，其实需要自己不断去尝试获取锁，比较消耗性能。

但是另一方面使用redis实现分布式锁在很多企业中非常常见，而且大部分情况下都不会遇到所谓的“极端复杂场景”

所以使用redis作为分布式锁也不失为一种好的方案，最重要的一点是redis的性能很高，可以支撑高并发的获取、释放锁操作。

对于zk分布式锁而言:

zookeeper天生设计定位就是分布式协调，强一致性。锁的模型健壮、简单易用、适合做分布式锁。
如果获取不到锁，只需要添加一个监听器就可以了，不用一直轮询，性能消耗较小。

但是zk也有其缺点：如果有较多的客户端频繁的申请加锁、释放锁，对于zk集群的压力会比较大。

小结：

综上所述，redis和zookeeper都有其优缺点。我们在做技术选型的时候可以根据这些问题作为参考因素。

建议

通过前面的分析，实现分布式锁的两种常见方案：redis和zookeeper，他们各有千秋。应该如何选型呢？

就个人而言的话，我比较推崇zk实现的锁：

因为redis是有可能存在隐患的，可能会导致数据不对的情况。但是，怎么选用要看具体在公司的场景了。

如果公司里面有zk集群条件，优先选用zk实现，但是如果说公司里面只有redis集群，没有条件搭建zk集群。

那么其实用redis来实现也可以，另外还可能是系统设计者考虑到了系统已经有redis，但是又不希望再次引入一些外部依赖的情况下，可以选用redis。

posted @ 2022-02-05 16:29 hanease 阅读(217) 评论(0) 编辑收藏举报

刷新页面返回顶部

hanease