面试不懂分布式锁？那得多吃亏。。。
做者：jianfengnode
本文来自读者的投稿redis
------------------------------------算法
为何用分布式锁？
在讨论这个问题以前，咱们先来看一个业务场景：数据库
系统A是一个电商系统，目前是一台机器部署，系统中有一个用户下订单的接口，可是用户下订单以前必定要去检查一下库存，确保库存足够了才会给用户下单。api
因为系统有必定的并发，因此会预先将商品的库存保存在redis中，用户下单的时候会更新redis的库存。安全
此时系统架构以下：bash
可是这样一来会产生一个问题：假如某个时刻，redis里面的某个商品库存为1，此时两个请求同时到来，其中一个请求执行到上图的第3步，更新数据库的库存为0，可是第4步尚未执行。微信
而另一个请求执行到了第2步，发现库存仍是1，就继续执行第3步。架构
这样的结果，是致使卖出了2个商品，然而其实库存只有1个。并发
很明显不对啊！这就是典型的库存超卖问题
此时，咱们很容易想到解决方案：用锁把二、三、4步锁住，让他们执行完以后，另外一个线程才能进来执行第2步。
按照上面的图，在执行第2步时，使用Java提供的synchronized或者ReentrantLock来锁住，而后在第4步执行完以后才释放锁。
这样一来，二、三、4 这3个步骤就被“锁”住了，多个线程之间只能串行化执行。
可是好景不长，整个系统的并发飙升，一台机器扛不住了。如今要增长一台机器，以下图：
增长机器以后，系统变成上图所示，个人天！
假设此时两个用户的请求同时到来，可是落在了不一样的机器上，那么这两个请求是能够同时执行了，仍是会出现库存超卖的问题。
为何呢？由于上图中的两个A系统，运行在两个不一样的JVM里面，他们加的锁只对属于本身JVM里面的线程有效，对于其余JVM的线程是无效的。
所以，这里的问题是：Java提供的原生锁机制在多机部署场景下失效了
这是由于两台机器加的锁不是同一个锁(两个锁在不一样的JVM里面)。
那么，咱们只要保证两台机器加的锁是同一个锁，问题不就解决了吗？
此时，就该分布式锁隆重登场了，分布式锁的思路是：
在整个系统提供一个全局、惟一的获取锁的“东西”，而后每一个系统在须要加锁时，都去问这个“东西”拿到一把锁，这样不一样的系统拿到的就能够认为是同一把锁。
至于这个“东西”，能够是Redis、Zookeeper，也能够是数据库。
文字描述不太直观，咱们来看下图：
经过上面的分析，咱们知道了库存超卖场景在分布式部署系统的状况下使用Java原生的锁机制没法保证线程安全，因此咱们须要用到分布式锁的方案。
那么，如何实现分布式锁呢？接着往下看！
基于Redis实现分布式锁
上面分析为啥要使用分布式锁了，这里咱们来具体看看分布式锁落地的时候应该怎么样处理。
最多见的一种方案就是使用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();复制代码
基于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实现分布式锁的底层原理和上面分析的是差很少的。这里咱们用一张图详细描述其原理：
小结：
本节介绍了zookeeperr实现分布式锁的方案以及zk的开源客户端的基本使用，简要的介绍了其实现原理。
两种方案的优缺点比较
学完了两种分布式锁的实现方案以后，本节须要讨论的是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。
这个是要系统设计者基于架构的考虑了
END
推荐一个专栏：
《从零开始带你成为JVM实战高手》
做者是我多年好友，之前团队的左膀右臂
一块儿经历过各类大型复杂系统上线的血雨腥风
现任阿里资深技术专家，对JVM有丰富的生产实践经验
专栏目录参见文末，能够扫下方海报进行试读
经过上面海报购买，再返你24元
领取方式：加微信号：Giotto1245，暗号：返现
- 1. 面试不懂分布式锁？那得多吃亏。。。
- 2. 不懂Spring的9种设计模式，面试会吃亏的
- 3. AI岗位面试抓不住重点，究竟有多吃亏？
- 4. 分布式锁那点事
- 5. 轻松搞懂锁和分布式锁
- 6. redis分布式锁实现-面试题
- 7. 分布式锁的实现面试题
- 8. redis的分布式锁（面试题）
- 9. 面试：你懂什么是分布式系统吗？Redis分布式锁都不会？
- 10. 面试官三连问：分布式锁你知道多少？
- 更多相关文章...
- • ASP.NET Web Pages - 页面布局 - ASP.NET 教程
- • Redis发布订阅模式 - Redis教程
- • 再有人问你分布式事务，把这篇扔给他
- • 常用的分布式事务解决方案
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. 面试不懂分布式锁？那得多吃亏。。。
- 2. 不懂Spring的9种设计模式，面试会吃亏的
- 3. AI岗位面试抓不住重点，究竟有多吃亏？
- 4. 分布式锁那点事
- 5. 轻松搞懂锁和分布式锁
- 6. redis分布式锁实现-面试题
- 7. 分布式锁的实现面试题
- 8. redis的分布式锁（面试题）
- 9. 面试：你懂什么是分布式系统吗？Redis分布式锁都不会？
- 10. 面试官三连问：分布式锁你知道多少？