本文讨论了如何在分布式环境中使用Redis作为缓存和分布式锁，包括不同版本的锁实现、Redisson的解决方案以及Redis面试中常见的问题，如数据一致性、缓存穿透的处理等。
1.缓存
当执行增删改操作时，必须保证缓存和数据库数据的一致性。----删除缓存
StudentServiceImpl
@Service
public class StudentServiceImpl implements StudentService {
@Autowired
private StudentMapper studentMapper;
@Autowired
private RedisTemplate<String,Object> redisTemplate;
@Override
public Student getById(Integer id) {
ValueOperations<String,Object> forValue = redisTemplate.opsForValue();
//1.查询缓存
Object o = forValue.get("student::" + id);
if(o!= null){ //缓存命中
return (Student) o;
}
Student student = studentMapper.selectById(id);
//2.查询到应放入缓存
if(student != null){
forValue.set("student::"+id,student);
}
return student;
}
//增
@Override
public Student insert(Student student) {
//新增的数据 缓存中肯定没有，所以不用删除
int insert = studentMapper.insert(student);
return student;
}
//删
@Override
public Integer delete(Integer id) {
//先删除缓存，在删除数据库中的数据
/**
* 需要缓存与数据库中数据保持一致
* */
redisTemplate.delete("student::"+id);
int i = studentMapper.deleteById(id);
return i;
}
//改
@Override
public Student updatet(Student student) {
//修改先删除缓存中的数据
redisTemplate.delete("student::"+student.getSid());//缓存与数据库中的数据保持一致
int update = studentMapper.updateById(student);
return student;
}
}StudentController
@RestController
@RequestMapping("student")
public class StudentController {
@Autowired
private StudentService studentService;
@GetMapping("getById/{id}")
public Student getById(@PathVariable Integer id){
return studentService.getById(id);
}
//增加
@GetMapping("insert")
public Student insert(Student student){
return studentService.insert(student);
}
//删除
@GetMapping("delete/{id}")
public Integer delete(@PathVariable Integer id){
return studentService.delete(id);
}
//修改
@GetMapping("update")
public Student update(Student student){
return studentService.updatet(student);
}
}2、Redis使用分布式锁
2.1 .1版本
entity (pojo)
@Data
@TableName(value = "product")
public class Stock {
@TableId(type = IdType.AUTO)
private int productid;
private Integer num;
}dao
@Mapper
public interface StockDao extends BaseMapper<Stock> {
}service
@Service
public class StockService_lock_syn {
@Autowired
private StockDao stockDao;
public static Object o = new Object();
public String jianStock(Integer pid){
//1.查询指定的商品库存
Stock stock = stockDao.selectById(pid);
if(stock.getNum() > 0){
//2.库存减1
stock.setNum(stock.getNum() - 1);
stockDao.updateById(stock);
System.out.println("库存剩余数量:"+stock.getNum());
return "减库存成功";
}else {
System.out.println("库存不足");
return "减库存失败";
}
}
}controller
@RestController
@RequestMapping("stock")
public class StockController {
@Autowired
private StockService_lock_syn stockService;
@GetMapping("decr/{pid}")
public String decr(@PathVariable int pid){
return stockService.jianStock(pid);
}
}RedisLockApplication
@SpringBootApplication
public class RedisLockApplication {
public static void main(String[] args) {
SpringApplication.run(RedisLockApplication.class, args);
}
@Bean //创建redisson交于spring容器来管理
public RedissonClient redisson() {
Config config = new Config();
config.setLockWatchdogTimeout(300);
config.useSingleServer().setAddress("redis://192.168.xxx.xxx:6379");
RedissonClient redisson = Redisson.create(config);
return redisson;
}
}
使用 jmeter 压测工具 测试
同一个库存数被多个线程买，产生线程安全问题。怎么解决超卖？
怎么解决线程安全问题
synchronized
Lock
2.1 .2版本
synchroniezd 锁
service
@Service
public class StockService_lock_syn {
@Autowired
private StockDao stockDao;
public static Object o = new Object();
public synchronized String jianStock(Integer pid){
//1.查询指定的商品库存
Stock stock = stockDao.selectById(pid);
if(stock.getNum() > 0){
//2.库存减1
stock.setNum(stock.getNum() - 1);
stockDao.updateById(stock);
System.out.println("库存剩余数量:"+stock.getNum());
return "减库存成功";
}else {
System.out.println("库存不足");
return "减库存失败";
}
}
}
Lock 锁
service
@Service
public class StockService_lock_syn {
@Autowired
private StockDao stockDao;
public static Object o = new Object();
//加lock锁
Lock lock = new ReentrantLock();
public String jianStock(Integer pid){
try{
lock.lock();//加锁
//1.查询指定的商品库存
Stock stock = stockDao.selectById(pid);
if(stock.getNum() > 0){
//2.库存减1
stock.setNum(stock.getNum() - 1);
stockDao.updateById(stock);
System.out.println("库存剩余数量:"+stock.getNum());
return "减库存成功";
}else {
System.out.println("库存不足");
return "减库存失败";
}
}finally {
lock.unlock();//释放锁
}
}
}
上面两种加锁的方法都没有出现重卖的现象。
上面的synchronized或lock锁是否适合集群模式 | 分布式系统？
不适合，因为synchronized和lock都是基于JVM的本地锁
2.1 .3版本
需要在idea中跑项目的集群 （idea右上角----点击进去---左上角有“+”）
配置nginx
两台集群会出现重卖问题。
1.2使用redis来解决分布式锁
依赖
<!--redis依赖-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-pool2</artifactId>
</dependency>1.2.3版本
service
@Service
public class StockService_lock_syn {
@Autowired
private StockDao stockDao;
@Autowired
private StringRedisTemplate redisTemplate;
public static Object o = new Object();
//2.0版本
public String jianStock(Integer pid){
//占锁
ValueOperations<String, String> forValue = redisTemplate.opsForValue();
// Boolean aBoolean = forValue.setIfAbsent("product::" + pid, "", 30, TimeUnit.SECONDS);
//占锁失败
while (!forValue.setIfAbsent("product::" + pid, "", 30, TimeUnit.SECONDS)){
try {
Thread.sleep(20);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//占锁成功
try {
//1. 查询指定的商品库存
Stock stock = stockDao.selectById(pid);
if (stock.getNum() > 0) {
//2.库存减1
stock.setNum(stock.getNum() - 1);
stockDao.updateById(stock);
System.out.println("库存剩余数量:" + stock.getNum());
return "减库存成功";
} else {
System.out.println("库存不足");
return "库存减失败";
}
}finally {
//释放锁资源
redisTemplate.delete("product::"+pid);
}
}
} 
没有重复卖的现象。
上面这个1.2.3版本，会发生超时问题
如果业务代码的执行时间超过30s,当前线程删除的时其他线程的锁资源 超时问题
watchDog机制 （看门狗)
每个10s检测当前线程是否还持有所资源，如果持有则为当前线程延迟。---可以自己设置watchDog机制，---第三方Redission完美的解决分布式锁。
1.3redisson完美解决redis超时问题
(1)添加redisson依赖
<dependency>
<groupId>org.redisson</groupId>
<artifactId>redisson</artifactId>
<version>3.13.4</version>
</dependency>（2）main函数 创建redisson交于spring容器来管理
@SpringBootApplication
public class RedisLockApplication {
public static void main(String[] args) {
SpringApplication.run(RedisLockApplication.class, args);
}
@Bean //创建redisson交于spring容器来管理
public RedissonClient redisson() {
Config config = new Config();
config.setLockWatchdogTimeout(300);
config.useSingleServer().setAddress("redis://192.168.xxx.xxx:6379");
RedissonClient redisson = Redisson.create(config);
return redisson;
}
}1.2.4版本
使用redisson完美解决redis超时问题
service
@Service
public class StockService_lock_syn {
@Autowired
private StockDao stockDao;
@Autowired
private StringRedisTemplate redisTemplate;
@Autowired
private RedissonClient redisson;
//3.0版本
public String jianStock(Integer pid){
RLock lock = redisson.getLock("product::" + pid);
try {
lock.lock(30,TimeUnit.SECONDS);//加锁: 如果程序执行是出现一次
//1. 查询指定的商品库存
Stock stock = stockDao.selectById(pid);
if (stock.getNum() > 0) {
//2.库存减1
stock.setNum(stock.getNum() - 1);
stockDao.updateById(stock);
System.out.println("库存剩余数量:" + stock.getNum());
return "减库存成功";
} else {
System.out.println("库存不足");
return "库存减失败";
}
}finally {
lock.unlock();
}
}
}3, Redis相关面试题
① Redis是什么？
redis是使用C语言编写的一个高速缓存数据，它以key-value形式存储数据，而且它支持的数 据类型非常丰富。
②Redis都有哪些使用场景？
1.热点数据的缓存
2.计时器
3. 排行榜
4. 实现分布式锁
5. 使用session的共享
③Redis支持的数据类型有哪些？
String Hash List Set ZSet
④Redis为什么是单线程的？
因为Redis是基于内存的操作，CPU不是Redis的瓶颈，Redis的瓶颈最有可能是机器内存的大小或者网络带宽。既然单线程容易实现，而且CPU不会成为瓶颈，那就顺理成章的采用单线程的方案了。
⑤Redis真的是单线程的吗？
并不是真的单线程，比如:RDB---Bgsave时，创建一个子线程
⑥Redis持久化有几种方式？
RDB ：快照模式 在一定时间间隔内，对当前redis内存中的数据进行拍照存储
AOF ：日志追加 每次执行的写命令，都会通过一个函数write记录到日志中
⑦什么是缓存穿透？怎么解决？
-
查询的数据在数据库中不存在，缓存中也不存在，这时有可能有人恶意访问这种数据。这些请求都会访问数据库，从而出现数据库压力过大。
情景: 比如id不合法---
确实数据库中不存在。
解决: 1. 在controller加校验
2. 我们可以在缓存中存入一个空对象，但是对象的过期时间不要太长，一般不会超过5分钟。
3. 可以使用布隆过滤器
⑧怎么保证缓存和数据库数据的一致性？
-
设置合理的过期时间
-
当执行增删改时需要删除缓存数据
⑨Redis，什么是缓存雪崩？怎么解决？
缓存雪崩:就是在某一时刻出现大量数据过期，而这时就有大量的请求访问该数据，这种现象叫做缓存雪崩。
什么情况下会出现大量数据过期:
-
项目刚刚上线
-
redis服务器宕机
-
缓存数据真实过期
解决方案:
-
上线前预热数据。
-
集群
-
设置过期时间时要分散设置。
⑩Redis怎么实现分布式锁？
使用redis中的setnx命令--占锁，当业务代码执行完毕后是否锁资源，而释放锁的命令是del。
11.redis在实现分布式锁式有什么缺陷
超时问题: 业务代码执行时间超过锁时间。使用:watchDog机制。 我们使用第三方:redisson
12.Redis 淘汰策略有哪些？
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
