详解Redis分布式锁（图文并茂，手把手搭建服务，代码详解，建议收藏）

面试宝典

面试必问知识点、BATJ历年历年面试真题+解析

学习经验总结

（一）调整好心态
心态是一个人能否成功的关键，如果不调整好自己的心态，是很难静下心来学习的，尤其是现在这么浮躁的社会，大部分的程序员的现状就是三点一线，感觉很累，一些大龄的程序员更多的会感到焦虑，而且随着年龄的增长，这种焦虑感会越来越强烈，那么唯一的解决办法就是调整好自己的心态，要做到自信、年轻、勤奋。这样的调整，一方面对自己学习有帮助，另一方面让自己应对面试更从容，更顺利。

（二）时间挤一挤，制定好计划
一旦下定决心要提升自己，那么再忙的情况下也要每天挤一挤时间，切记不可“两天打渔三天晒网”。另外，制定好学习计划也是很有必要的，有逻辑有条理的复习，先查漏补缺，然后再系统复习，这样才能够做到事半功倍，效果才会立竿见影。

（三）不断学习技术知识，更新自己的知识储备
对于一名程序员来说，技术知识方面是非常重要的，可以说是重中之重。**要面试大厂，自己的知识储备一定要非常丰富，若缺胳膊少腿，别说在实际工作当中，光是面试这一关就过不了。**对于技术方面，首先基础知识一定要扎实，包括自己方向的语言基础、计算机基础、算法以及编程等等。

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化学习资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

127.0.0.1:6379> set lock true EX 10 NX        # 设置 10s生效

OK

127.0.0.1:6379> set lock true EX 10 NX        # 10s内再次设值失败

(nil)

127.0.0.1:6379> set lock true EX 10 NX        # 10s后设置成功

OK

如上这个操作就成功的解决了Redis分布式锁的原子操作问题。

​

2.2.4 解锁

Redis分布式锁加锁在上面讲述了，而Redis分布式锁的解锁过程其实就是将key删除，key的删除有客户端调用del指令删除，也有设置key的过期时间自动删除。但是这个删除不能乱删除，不能说客户端A请求的锁被客户端B给删除了……，那这把锁就是一把烂锁了。

为了防止客户端A请求的锁被客户端B给删除了这种情况，我们通过匹配客户端传入的锁的值与当前锁的值是否相等来做判断（这个值是随机且保证不会重复的），如果相等就删除，解锁成功。

但是Redis并未提供这样的功能，我们只能通过Lua脚本来处理，因为Lua脚本可以保证多个指令的原子性执行。

示例：

首先设置一个key，这个key的值是123456789，通过客户端传入的value值是否相等来校验是否允许删除这个key

127.0.0.1:6379> get lock

(nil)

127.0.0.1:6379> set lock 123456789 # 设置一个key 值为123456789

OK

127.0.0.1:6379> get lock

“123456789”

在客户机上编写lua脚本，lock.lua文件，文件内容如下

if redis.call(“get”,KEYS[1]) == ARGV[1] then

return redis.call(“del”,KEYS[1])

else

return 0

end

测试通过错误的value值去执行lua脚本，这个时候删除key失败，返回0

通过正确的value值执行则返回1，说明key被删除了。

2.2.5 代码实现

一下演示一个spring boot项目来实现Redis分布式锁，为了方便大家使用，我贴出的代码比较全面，篇幅稍多。

pom依赖

org.springframework.boot

spring-boot-starter-parent

2.3.4.RELEASE

org.springframework.boot

spring-boot-starter-web

redis.clients

jedis

3.0.1

org.projectlombok

lombok

cn.hutool

hutool-all

5.3.4

Redis配置文件

package com.lizba.config;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.springframework.beans.factory.annotation.Value;

import org.springframework.cache.annotation.CachingConfigurerSupport;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;

import redis.clients.jedis.JedisPool;

import redis.clients.jedis.JedisPoolConfig;

/**

•     Redis简单配置文件
  

• @Author: Liziba

• @Date: 2021/7/11 11:17

*/

@Configuration

public class RedisConfig extends CachingConfigurerSupport {

protected static final Logger logger = LoggerFactory.getLogger(RedisConfig.class);

@Value(“${spring.redis.host}”)

private String host;

@Value(“${spring.redis.port}”)

private int port;

@Value(“${spring.redis.jedis.pool.max-active}”)

private int maxTotal;

@Value(“${spring.redis.jedis.pool.max-idle}”)

private int maxIdle;

@Value(“${spring.redis.jedis.pool.min-idle}”)

private int minIdle;

@Value(“${spring.redis.password}”)

private String password;

@Value(“${spring.redis.timeout}”)

private int timeout;

@Bean

public JedisPool redisPoolFactory() {

JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();

jedisPoolConfig.setMaxTotal(maxTotal);

jedisPoolConfig.setMaxIdle(maxIdle);

jedisPoolConfig.setMinIdle(minIdle);

JedisPool jedisPool = new JedisPool(jedisPoolConfig, host, port, timeout, null);

logger.info(“JedisPool注入成功！！”);

logger.info(“redis地址：” + host + “:” + port);

return jedisPool;

}

}

application.yml配置文件

server:

port: 18080

spring:

redis:

database: 0

host: 127.0.0.1

port: 6379

timeout: 10000

password:

jedis:

pool:

max-active: 20

max-idle: 20

min-idle: 0

获取锁与释放锁代码

package com.lizba.utill;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Service;

import redis.clients.jedis.Jedis;

import redis.clients.jedis.JedisPool;

import redis.clients.jedis.params.SetParams;

import java.util.Arrays;

import java.util.concurrent.TimeUnit;

/**

•   Redis分布式锁简单工具类
  

• @Author: Liziba

• @Date: 2021/7/11 11:42

*/

@Service

public class RedisLockUtil {

private static Logger logger = LoggerFactory.getLogger(RedisLockUtil.class);

/**

• 锁键 -> key

*/

private final String LOCK_KEY = “lock_key”;

/**

• 锁过期时间 -> TTL

*/

private Long millisecondsToExpire = 10000L;

/**

• 获取锁超时时间 -> get lock timeout for return

*/

private Long timeout = 300L;

/**

• LUA脚本 -> 分布式锁解锁原子操作脚本

*/

private static final String LUA_SCRIPT =

“if redis.call(‘get’,KEYS[1]) == ARGV[1] then” +

" return redis.call(‘del’,KEYS[1]) " +

“else” +

" return 0 " +

“end”;

/**

• set命令参数

*/

private SetParams params = SetParams.setParams().nx().px(millisecondsToExpire);

@Autowired

private JedisPool jedisPool;

/**

• 加锁 -> 超时锁

• @param lockId 一个随机的不重复id -> 区分不同客户端

• @return

*/

public boolean timeLock(String lockId) {

Jedis client = jedisPool.getResource();

long start = System.currentTimeMillis();

try {

for(;😉 {

String lock = client.set(LOCK_KEY, lockId, params);

if (“OK”.equalsIgnoreCase(lock)) {

return Boolean.TRUE;

}

// sleep -> 获取失败暂时让出CPU资源

TimeUnit.MILLISECONDS.sleep(100);

long time = System.currentTimeMillis() - start;

if (time >= timeout) {

return Boolean.FALSE;

}

}

} catch (Exception e) {

e.printStackTrace();

logger.error(e.getMessage());

} finally {

client.close();

}

return Boolean.FALSE;

}

/**

• 解锁

• @param lockId 一个随机的不重复id -> 区分不同客户端

• @return

*/

public boolean unlock(String lockId) {

Jedis client = jedisPool.getResource();

try {

Object result = client.eval(LUA_SCRIPT, Arrays.asList(LOCK_KEY), Arrays.asList(lockId));

if (result != null && “1”.equalsIgnoreCase(result.toString())) {

return Boolean.TRUE;

}

return Boolean.FALSE;

} catch (Exception e) {

e.printStackTrace();

logger.error(e.getMessage());

}

return Boolean.FALSE;

}

}

测试类

package com.lizba.controller;

import cn.hutool.core.util.IdUtil;

import com.lizba.utill.RedisLockUtil;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.web.bind.annotation.GetMapping;

import org.springframework.web.bind.annotation.PathVariable;

import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.RestController;

import java.util.HashSet;

import java.util.Set;

import java.util.concurrent.CountDownLatch;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

import java.util.concurrent.atomic.AtomicInteger;

/**

•   测试
  

• @Author: Liziba

• @Date: 2021/7/11 12:27

*/

@RestController

@RequestMapping(“/redis”)

public class TestController {

@Autowired

private RedisLockUtil redisLockUtil;

private AtomicInteger count ;

@GetMapping(“/index/{num}”)

public String index(@PathVariable int num) throws InterruptedException {

count = new AtomicInteger(0);

CountDownLatch countDownLatch = new CountDownLatch(num);

ExecutorService executorService = Executors.newFixedThreadPool(num);

Set failSet = new HashSet<>();

long start = System.currentTimeMillis();

for (int i = 0; i < num; i++) {

executorService.execute(() -> {

long lockId = IdUtil.getSnowflake(1, 1).nextId();

try {

boolean isSuccess = redisLockUtil.timeLock(String.valueOf(lockId));

if (isSuccess) {

count.addAndGet(1);

System.out.println(Thread.currentThread().getName() + " lock success" );

} else {

failSet.add(Thread.currentThread().getName());

}

} finally {

boolean unlock = redisLockUtil.unlock(String.valueOf(lockId));

if (unlock) {

System.out.println(Thread.currentThread().getName() + " unlock success" );

}

}

countDownLatch.countDown();

});

}

countDownLatch.await();

executorService.shutdownNow();

failSet.forEach(t -> System.out.println(t + " lock fail" ));

long time = System.currentTimeMillis() - start;

return String.format(“Thread sum: %d, Time sum: %d, Success sum：%d”, num, time, count.get());

}

}

测试结果

2.3 Redis的超时问题

Redis分布式锁有一个问题是锁的超时问题，也就是说如果客户端A获取到锁之后去执行任务，任务没跑完锁的超时时间到了，锁就会自动释放，这个时候客户端B就能乘虚而入了，锁就会出现问题！

关于这个问题其实并没有完全的解决办法，但是能通过如下手段去优化：

1. 尽可能不要在Redis分布式锁中执行较长的任务，尽可能的缩小锁区间内执行代码，就像单JVM锁中的synchronized优化一样，我们可以考虑优化锁的区间

2. 多做压力测试和线上真实场景的模拟测试，估算一个合适的锁超时时间

3. 做好Redis分布式锁超时任务未执行完的问题发生后，数据恢复手段的准备

三、集群中的分布式锁

---

3.1 集群分布式锁存在的问题

上述的分布式锁，针对单节点实例的Redis是可行的；但是我们在公司根本不会用单节点的Redis实例，往往采用最简单的都是是Redis一主二从+Sentinel监控配置；在sentinel集群中，虽然主节点挂掉时，从节点会取而代之，客户端无感知，但是上述的分布式锁就可能存在节点之间数据同步异常导致分布式锁失效的问题。

正常情况下客户端向sentinel监控的Redis集群申请分布式锁：

比如，客户端A在主节点（机器1）上申请了一把锁，此时主节点（机器1）挂掉了且锁没来得及同步到从节点（机器2和机器3），此时从节点（机器2）成为了新的主节点，但是锁在新的主节点（机器2）上并不存在，所以客户端B申请锁成功，锁的定义在这种场景中就出现了问题！

主节点宕机锁同步失败情况，其他客户端申请锁成功：

上述这种情况虽然之后发生在主从发生failover的情况才产生，但显然是不安全的，普通的业务系统或许能接受，但大金额的业务场景是不允许出现的。

3.2 RedLock

结尾

最后，针对上面谈的内容，给大家推荐一个Android资料，应该对大家有用。

首先是一个知识清单：（对于现在的Android及移动互联网来说，我们需要掌握的技术）

泛型原理丶反射原理丶Java虚拟机原理丶线程池原理丶
注解原理丶注解原理丶序列化
Activity知识体系（Activity的生命周期丶Activity的任务栈丶Activity的启动模式丶View源码丶Fragment内核相关丶service原理等）
代码框架结构优化（数据结构丶排序算法丶设计模式）
APP性能优化（用户体验优化丶适配丶代码调优）
热修复丶热升级丶Hook技术丶IOC架构设计
NDK（c编程丶C++丶JNI丶LINUX）
如何提高开发效率？
MVC丶MVP丶MVVM
微信小程序
Hybrid
Flutter

接下来是资料清单：（敲黑板！！！）

---

1.数据结构和算法

2.设计模式

3.全套体系化高级架构视频；七大主流技术模块，视频+源码+笔记

4.面试专题资料包（怎么能少了一份全面的面试题总结呢~）

不论遇到什么困难，都不应该成为我们放弃的理由！共勉~

如果你看到了这里，觉得文章写得不错就给个赞呗？如果你觉得那里值得改进的，请给我留言。一定会认真查询，修正不足。谢谢。

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化学习资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

式）

APP性能优化（用户体验优化丶适配丶代码调优）
热修复丶热升级丶Hook技术丶IOC架构设计
NDK（c编程丶C++丶JNI丶LINUX）
如何提高开发效率？
MVC丶MVP丶MVVM
微信小程序
Hybrid
Flutter

[外链图片转存中…(img-BZ4FVDWA-1715472621780)]

接下来是资料清单：（敲黑板！！！）

---

1.数据结构和算法

[外链图片转存中…(img-eIpzsrH3-1715472621780)]

2.设计模式

[外链图片转存中…(img-sZwFG6BI-1715472621781)]

3.全套体系化高级架构视频；七大主流技术模块，视频+源码+笔记

[外链图片转存中…(img-sZGDEeNB-1715472621781)]

4.面试专题资料包（怎么能少了一份全面的面试题总结呢~）

[外链图片转存中…(img-cVmYwj3t-1715472621781)]

不论遇到什么困难，都不应该成为我们放弃的理由！共勉~

如果你看到了这里，觉得文章写得不错就给个赞呗？如果你觉得那里值得改进的，请给我留言。一定会认真查询，修正不足。谢谢。

[外链图片转存中…(img-LIAsS0wG-1715472621782)]

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化学习资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！