Redis缓存优化、本地锁及分布式锁的入门使用思想实现
1、依赖启动器引入
<!-- redis -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<!-- spring2.X集成redis所需common-pool2-->
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-pool2</artifactId>
<version>2.6.0</version>
</dependency>
2、操作Redis序列化配置类
万能是配置类，只要使用redis作为缓存的都可以实体下面的配置类
序列化与默认序列化的区别
| 数据结构 | KEY或VALUE序列化设置 | 具体的序列化类 | 序列化前 | 序列化后 |
|---|---|---|---|---|
| Key / Value | ValueSerializer | StringRedisSerializer | test_value111 | test_value111 |
| ValueSerializer | Jackson2JsonRedisSerializer | test_value111 | “test_value111” | |
| ValueSerializer | JdkSerializationRedisSerializer | test_value111 | ??? |
package com.zcl.gmall.common.config;
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
/**
* @author: xiao_zhong
* @description: Redis配置类
* @date: 2022/11/16 9:55
* @param: null
* @return:
*/
@Configuration
@EnableCaching
public class RedisConfig {
@Bean
public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
RedisTemplate<Object, Object> redisTemplate = new RedisTemplate<>();
// 设置redis的连接池工厂。
redisTemplate.setConnectionFactory(redisConnectionFactory);
// 设置序列化的(在查看redis数据的时候不会出现乱码)。
Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
ObjectMapper objectMapper = new ObjectMapper();
objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
jackson2JsonRedisSerializer.setObjectMapper(objectMapper);
// 将Redis 中 string ，hash 数据类型，自动序列化！
redisTemplate.setKeySerializer(new StringRedisSerializer());
redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
// 设置数据类型是Hash 的 序列化！
redisTemplate.setHashKeySerializer(new StringRedisSerializer());
redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
redisTemplate.afterPropertiesSet();
return redisTemplate;
}
}
3、配置Redis的连接信息
spring:
redis:
host: xxx.xxx.xxx.xxx
port: 6379
database: 0
timeout: 1800000
password:
lettuce:
pool:
max-active: 20 #最大连接数
max-wait: -1 #最大阻塞等待时间(负数表示没限制)
max-idle: 5 #最大空闲
min-idle: 0 #最小空闲
4、定义操作Redis的Key常量
redis的key是不能进行重复的，否则数据会覆盖，同时也不会通过硬编码的形式写死在储存的key位置上，这样不便于后面的维护，一般都是通过定义
枚举、接口、静态类进行统一的描述key的使用，这样在后面需要进行key重新定义的时候就可以一处修改处处生效
package com.zcl.gmall.common.constant;
public class RedisConst {
/**单位：秒 尝试获取锁的最大等待时间*/
public static final long SKULOCK_EXPIRE_PX1 = 1;
/**单位：秒 锁的持有时间*/
public static final long SKULOCK_EXPIRE_PX2 = 1;
/**锁的后缀*/
public static final String SKULOCK_SUFFIX = ":lock";
}
5、本地锁和分布式锁的基本思路流程图
5.1、本地锁
5.2、分布式锁
6、本地锁实现案例
6.1、定义Redis中的初始化数据
6.2、控制器编写
package com.zcl.gmall.product.controller;
import com.zcl.gmall.product.service.TestService;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import javax.annotation.Resource;
/**
* @Author: zcl
* @description: 测试Redis分布式锁控制器
* @DATE: 2022/12/8 10:21 星期四
* @Version 1.0
*/
@RestController
@RequestMapping("/admin/product/test")
public class TestRedisController {
/**
* 描述：注入业务接口
*/
@Resource
private TestService testService;
/**
* @author: mac
* @description: 测试本地锁
* @date: 2022/12/8 10:23
* @param:
* @return: java.lang.String
*/
@GetMapping("/testLock")
public String testLock() {
return testService.testLock();
}
}
6.3、业务接口实现
package com.zcl.gmall.product.service.impl;
import com.zcl.gmall.product.service.TestService;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;
import javax.annotation.Resource;
/**
* @Author: zcl
* @description: 测试Redis测试接口实现类
* @DATE: 2022/12/8 10:25 星期四
* @Version 1.0
*/
@Service
public class TestServiceImpl implements TestService {
/**
* 描述：注入redis的操作模板接口
*/
@Resource
private StringRedisTemplate stringRedisTemplate;
/**
* @author: mac
* @description: 测试本地锁的局限性
* @date: 2022/12/8 10:26
* @param:
* @return: java.lang.String
*/
@Override
public String testLock() {
/**
* 实现步骤：
* 1、从redis中获取数据
* 2、对num数据进行+1操作
* 3、设置新的num到redis中
*/
String numValue = stringRedisTemplate.opsForValue().get("num");
if (StringUtils.isEmpty(numValue)) {
return "0";
}
Integer num = Integer.parseInt(numValue);
stringRedisTemplate.opsForValue().set("num", String.valueOf(++num));
return String.valueOf(num);
}
}
6.4、访问测试
1、单点访问
不是高并发访问，访问一次处理一次，再次查看Redis中储存的
num是否也等于12
注意：这里是点击了12次所以返回的也就是12
2、ab高并发测试
mac是自带ab压测，但是默认的有并发数限制需要重新安装
3、压测结果：
当没有个业务接口加锁的时候，修改的
num数据是不到5000的，也就是不能保证数据的唯一性存在很大的问题
如何加锁，只需要在业务接口实现类上添加synchronized关键字进行修饰即可添加上本地锁，再次通过上面的压测命令就可以得到redis中的num=5000，保证了数据的唯一性
4、集群测试本地锁思路
- 复制多个服务修改启动端口号进行启动
- 服务注册到nacos
- 创建网关服务并设置对应的请求断言，网关默认是
80直接访问会负载均衡到测试服务 - 再次通过
ab压测查看最后的redis中的num数据
分布式本地锁的局限性：
1、synchronized本地锁由jvm进行管理
2、搭建了集群模式就是三个不同的jvm管理synchronized本地锁
3、本地锁只能锁住同一工程内的资源，在分布式系统里面都存在局限性
7、Redis分布式锁案例
先完成三个微服务的穿件以及网关模块的搭建，能够正常访问到请求再进行下面的操作
为了确保分布式锁可用，我们至少要确保锁的实现同时满足以下四个条件：
- 互斥性。在任意时刻，只有一个客户端能持有锁。
- 不会发生死锁。即使有一个客户端在持有锁的期间崩溃而没有主动解锁，也能保证后续其他客户端能加锁。
- 解铃还须系铃人。加锁和解锁必须是同一个客户端，客户端自己不能把别人加的锁给解了。
- 加锁和解锁必须具有原子性
7.1、setnx占坑思想实现
1、创建控制器
/**
* @author: mac
* @description: redis的setnx占坑思想
* @date: 2022/12/8 14:46
* @param:
* @return: java.lang.String
*/
@GetMapping("/testLock2")
public String testLock2() {
return testService.testLock2();
}
2、业务接口实现
下面的业务接口实现了较为完善的redis分布式锁处理，通过使用uuId和lua脚本保证了删除锁的原子性
/**
* @author: mac
* @description: redis占坑思想实现
* @date: 2022/12/8 14:47
* @param:
* @return: java.lang.String
*/
@Override
public String testLock2() {
String uuId = UUID.randomUUID().toString().replaceAll("-", "");
/**
* 实现步骤：
* 1、获取锁
* 2、判断锁
* 3、释放锁
*/
Integer num = null;
// 设置过期时间，注意【过期时间需要根据业务的执行速度最终计算获得否则就会乱释放锁】
// 场景：7秒执行完的业务所的过期时间设置3秒，往后想想就知道锁会被释放错
Boolean lock = stringRedisTemplate.opsForValue().setIfAbsent("lock", uuId, 3, TimeUnit.SECONDS);
if (lock) {
String numValue = stringRedisTemplate.opsForValue().get("num");
if (StringUtils.isEmpty(numValue)) {
return "0";
}
num = Integer.parseInt(numValue);
stringRedisTemplate.opsForValue().set("num", String.valueOf(++num));
// 定义lua脚本
final String lu = "if redis.call(\"get\",KEYS[1]) == ARGV[1]\n" +
"then\n" +
" return redis.call(\"del\",KEYS[1])\n" +
"else\n" +
" return 0\n" +
"end";
DefaultRedisScript<Long> redisScript = new DefaultRedisScript<>();
// 设置lua脚本
redisScript.setScriptText(lu);
// 设置返回值类型
redisScript.setResultType(Long.class);
// 通过lua脚本进行删除，只要当key的值域uuId的值一致时才会进行删除(反之误删除，lua保证原子性)
stringRedisTemplate.execute(redisScript, Arrays.asList("lock"), uuId);
} else {
try {
// 没有获取到锁就自旋
Thread.sleep(100);
testLock2();
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
return String.valueOf(num);
}
3、ab测试
重新启动三个集群微服务，通过
ab进行压测网关然后负载均衡到各个微服务端口集合完成测试，当查询查看redis中的num=5000时，说明上面的setnx占坑实现的分布式锁是可以正常的使用的
7.2、redisson解决分布式锁
官网文档地址：https://github.com/redisson/redisson/wiki/8.-distributed-locks-and-synchronizers/#81-lock
加锁和释放锁的方法
RLock lock = redisson.getLock("myLock");
// traditional lock method
lock.lock();
// or acquire lock and automatically unlock it after 10 seconds
lock.lock(10, TimeUnit.SECONDS);
// or wait for lock aquisition up to 100 seconds
// and automatically unlock it after 10 seconds
boolean res = lock.tryLock(100, 10, TimeUnit.SECONDS);
if (res) {
try {
...
} finally {
lock.unlock();
}
}
1、引入依赖
<dependency>
<groupId>org.redisson</groupId>
<artifactId>redisson</artifactId>
<version>3.18.0</version>
</dependency>
2、搭建配置类
package com.zcl.gmall.common.config;
import lombok.Data;
import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
import org.redisson.config.SingleServerConfig;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.util.StringUtils;
/**
* @author: xiao_zhong
* @description: redisson配置信息
* @date: 2022/11/16 19:05
* @param: null
* @return:
*/
@Data
@Configuration
@ConfigurationProperties("spring.redis")
public class RedissonConfig {
/**连接主机IP*/
private String host;
/**地址*/
private String addresses;
/**连接密码*/
private String password;
/**连接端口号*/
private String port;
/**连接超时时间*/
private int timeout = 3000;
/**连接池大小*/
private int connectionPoolSize = 64;
/**最小空闲大小*/
private int connectionMinimumIdleSize=10;
/**ping连接间隔*/
private int pingConnectionInterval = 60000;
private static String ADDRESS_PREFIX = "redis://";
/**
* @author: xiao_zhong
* @description: 自动装配
* @date: 2022/11/16 19:05
* @param:
* @return: org.redisson.api.RedissonClient
*/
@Bean
RedissonClient redissonSingle() {
Config config = new Config();
if(StringUtils.isEmpty(host)){
throw new RuntimeException("host is empty");
}
SingleServerConfig serverConfig = config.useSingleServer()
// redis://127.0.0.1:7181
.setAddress(ADDRESS_PREFIX + this.host + ":" + port)
.setTimeout(this.timeout)
.setPingConnectionInterval(pingConnectionInterval)
.setConnectionPoolSize(this.connectionPoolSize)
.setConnectionMinimumIdleSize(this.connectionMinimumIdleSize)
;
if(!StringUtils.isEmpty(this.password)) {
serverConfig.setPassword(this.password);
}
return Redisson.create(config);
}
}
3、创建控制器
/**
* @author: mac
* @description: redisson解决分布式锁
* @date: 2022/12/8 18:18
* @param:
* @return: java.lang.String
*/
@GetMapping("testLock3")
public String testLock3() {
return testService.testLock3();
}
4、业务接口实现【可重入锁】
/**
* @author: xiao_zhong
* @description: redisson测试分布式锁
* @date: 2022/11/16 19:10
* @param:
* @return: void
*/
@Override
public void testLock3() {
// 1、定义缓存的key
String skuKey = "sku:" + 1317 + "info";
// 2、获取锁
RLock lock = redissonClient.getLock(skuKey);
try {
// 3、加锁一
// lock.lock();
// 加锁二：设置超时时间
// 加锁以后10秒钟自动解锁,无需调用unlock方法手动解锁
// lock.lock(7,TimeUnit.SECONDS);
// 加锁三：尝试加锁，最多等待100秒，上锁以后10秒自动解锁
boolean tryLock = lock.tryLock(100, 10, TimeUnit.SECONDS);
if(tryLock){
// 4、查询redis中的num数据++
String num = stringRedisTemplate.opsForValue().get("num");
if(StringUtils.isBlank(num)){
return;
}
int val = Integer.parseInt(num);
// 5、设置数据添加
stringRedisTemplate.opsForValue().set("num",String.valueOf(++val));
}else {
Thread.sleep(50);
testLock3();
}
} catch (InterruptedException e) {
throw new RuntimeException(e);
}finally {
// 6、释放锁
lock.unlock();
}
}
7.3、redisson（ReadWriteLock）读写锁操作
1、创建控制器
/**
* 注入测试业务接口
*/
@Autowired
private TestService testService;
/**
* @author: xiao_zhong
* @description: 写锁测试
* @date: 2022/11/16 20:04
* @param:
* @return: java.lang.String
*/
@GetMapping("/write")
public String write(){
return testService.writeLock4();
}
/**
* @author: xiao_zhong
* @description: 读锁测试
* @date: 2022/11/16 20:04
* @param:
* @return: java.lang.String
*/
@GetMapping("/read")
public String read(){
return testService.readLock4();
}
2、业务接口实现类编写
/**
* @author: mac
* @description: 写锁测试
* @date: 2022/12/8 19:06
* @param:
* @return: java.lang.String
*/
@Override
public String writeLock4() {
// 1、初始化获取锁
RReadWriteLock readWriteLock = redissonClient.getReadWriteLock("readWriteLock");
// 2、获取读锁
RLock rLock = readWriteLock.writeLock();
// 3、写锁
rLock.lock(10, TimeUnit.SECONDS);
// 4、写入redis
stringRedisTemplate.opsForValue().set("msg", String.valueOf(System.currentTimeMillis()));
// 5、释放锁
// rLock.unlock();
return "写入一条数据到redis中";
}
/**
* @author: mac
* @description: 读锁测试
* @date: 2022/12/8 19:06
* @param:
* @return: java.lang.String
*/
@Override
public String readLock4() {
// 1、初始化获取锁
RReadWriteLock readWriteLock = redissonClient.getReadWriteLock("readWriteLock");
// 2、获取读锁
RLock rLock = readWriteLock.readLock();
// 3、写锁
rLock.lock(10, TimeUnit.SECONDS);
// 4、写入redis
String msg = stringRedisTemplate.opsForValue().get("msg");
// 5、释放锁
// rLock.unlock();
return msg;
}
3、读写锁测试互斥性
同时将【读和写】的业务代码统一修改加锁的时间为
rLock.lock(10,TimeUnit.SECONDS);,并且将释放锁的代码rLock.unlock();注释掉说明：互斥说明，就是在请求的时候需要等待上面所设置的10秒过期时间才能真正访问到数据，否则浏览器一直在转圈等待
| 操作1 | 操作2 | 是否互斥 | 等待时间 |
|---|---|---|---|
| 读 | 读 | 不互斥 | 无 |
| 写 | 读 | 互斥 | 10s |
| 读 | 写 | 互斥 | 10s |
| 写 | 写 | 互斥 | 10s |
解决：只要涉及到写，就必须互斥
说明：如果上面的知识点有不妥或描述有误的地方请留言或私信交流更正
![[附源码]Python计算机毕业设计Django作业查重系统](https://img-blog.csdnimg.cn/5c8d66a6da27483fb0905b531461a4f8.png)
