一、问题的分布式锁定在我们请求分布式锁定时成功了。 但是这个时候，slave还没有复制我们的锁。 已关闭主节点。 当我们的APP应用程序继续请求锁定时，它将从其继任的原始存储区申请master，然后成功。
结果，同一锁被多次获取。
二、方法Redis针对这种情况，引入了红锁的概念。
三、原理是使用Redis中的多个master实例，获得锁定，大多数实例获得锁定，才能获得成功。 具体的红色锁定算法分为以下五个步骤。
以毫秒为单位获取当前时间。 使用相同的key和随机值在n个节点上请求锁定。 尝试在此获取锁定的时间远远短于锁定超时时间，以防止某些主停机。 我们还在继续获取锁定，但被屏蔽了很长时间。 只有在大多数节点上获取了锁定，并且总获取时间小于锁定超时时间时，才会认为锁定获取成功。 如果成功获取锁定，则锁定超时时间是第一次锁定超时时间用于获取锁定的总时间。 如果锁定获取失败，则无论成功获取的节点数是否超过一半，或者获取锁定所需的时间是否超过锁定释放时间，设置了key的主节点上的key都将被删除。 四、实战Redission实现红色锁定算法，使用步骤如下：
1、引进maven！ --- JDK 1.8兼容--- -从属关系组roupidorg.redis son/groupidartifactidredisson/artifactidredisson3.9.0/verstifactidversion artifactidversion config1. usesingleserver (.set address (' redis ://172.0.0.133605378 ).setpassword ) ' a 1234444 配置配置2=new config (； config2. usesingleserver (.set地址(' redis ://172.0.0.133605379 ).setpassword ) ' a123456 ' ).set redisword 配置配置3=new config (； config3. usesingleserver (.set地址(' redis ://172.0.0.133605380 ).setpassword ) ' a123456 ' ).set redisword /** *获取多个RLock对象*/rlock lock1=redissonclient1. get lock (lock key )； rocklock2=redissonclient2. get lock (锁定密钥)； rocklock3=redissonclient3. get lock (lock key )； /**基于多个RLock对象构建RedissonRedLock ()/redissonredlockredlock=newredissonredlock () lock1、lock2、lock3) ) try { /** * 4.尝试获取密钥*尝试获取等待时间out密钥的最大等待时间。 如果超过此值，则视为密钥获取失败的* leaseTime密钥的持有时间。 超过此时间后密钥将自动禁用()/booleanRES=redlock.trylock ) (waitTimeout，) long ) leaseTime，time uning 获得if(RES )//锁，在此处理业务) catch ) exceptione ) thrownewruntimeexception (' aquirelockfail ' )； }finally{ //无论如何，最后必须解锁redLock.unlock ()； 6三、核心源代码publicbooleantrylock (long wait time，long leaseTime，time unit ) throwsinterruptedexception ) longnewleasetime=- 最新时间！=-1 ) new lease time=unit.tomillis (wait time ) *2； } long time=system.current time millis (； 长寿命=-1；
if (waitTime != -1) { remainTime = unit.toMillis(waitTime); } long lockWaitTime = calcLockWaitTime(remainTime); /** * 1. 允许加锁失败节点个数限制（N-(N/2+1)） */ int failedLocksLimit = failedLocksLimit(); /** * 2. 遍历所有节点通过EVAL命令执行lua加锁 */ List<RLock> acquiredLocks = new ArrayList<>(locks.size()); for (ListIterator<RLock> iterator = locks.listIterator(); iterator.hasNext();) { RLock lock = iterator.next(); boolean lockAcquired; /** * 3.对节点尝试加锁 */ try { if (waitTime == -1 && leaseTime == -1) { lockAcquired = lock.tryLock(); } else { long awaitTime = Math.min(lockWaitTime, remainTime); lockAcquired = lock.tryLock(awaitTime, newLeaseTime, TimeUnit.MILLISECONDS); } } catch (RedisResponseTimeoutException e) { // 如果抛出这类异常，为了防止加锁成功，但是响应失败，需要解锁所有节点 unlockInner(Arrays.asList(lock)); lockAcquired = false; } catch (Exception e) { // 抛出异常表示获取锁失败 lockAcquired = false; } if (lockAcquired) { /** *4. 如果获取到锁则添加到已获取锁集合中 */ acquiredLocks.add(lock); } else { /** * 5. 计算已经申请锁失败的节点是否已经到达 允许加锁失败节点个数限制 （N-(N/2+1)） * 如果已经到达， 就认定最终申请锁失败，则没有必要继续从后面的节点申请了 * 因为 Redlock 算法要求至少N/2+1 个节点都加锁成功，才算最终的锁申请成功 */ if (locks.size() - acquiredLocks.size() == failedLocksLimit()) { break; } if (failedLocksLimit == 0) { unlockInner(acquiredLocks); if (waitTime == -1 && leaseTime == -1) { return false; } failedLocksLimit = failedLocksLimit(); acquiredLocks.clear(); // reset iterator while (iterator.hasPrevious()) { iterator.previous(); } } else { failedLocksLimit--; } } /** * 6.计算 目前从各个节点获取锁已经消耗的总时间，如果已经等于最大等待时间，则认定最终申请锁失败，返回false */ if (remainTime != -1) { remainTime -= System.currentTimeMillis() - time; time = System.currentTimeMillis(); if (remainTime <= 0) { unlockInner(acquiredLocks); return false; } } } if (leaseTime != -1) { List<RFuture<Boolean>> futures = new ArrayList<>(acquiredLocks.size()); for (RLock rLock : acquiredLocks) { RFuture<Boolean> future = ((RedissonLock) rLock).expireAsync(unit.toMillis(leaseTime), TimeUnit.MILLISECONDS); futures.add(future); } for (RFuture<Boolean> rFuture : futures) { rFuture.syncUninterruptibly(); } } /** * 7.如果逻辑正常执行完则认为最终申请锁成功，返回true */ return true;}