redis分布式锁

1.redis分布式锁

当执行增删改操纵时必须保证缓存和数据库数据一致性。

@Override
 public student insert(Student student) {
     int i = 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 update(student student) {
     //删除
     redisTemplate.delete("student::"+student.getstudentno()); //缓存与数据库数据保持一致
     int i = studentMapper.updateById(student);
     return student;
 }

2.redis使用分布式锁

（1）通过使用jmeter压测工具测试

(2)下面我们通过卖票的方式来看

package com.zmz.service;
import com.zmz.dao.StockDao;
import com.zmz.entity.Stock;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
/**
 * @program: redis-lock-qy145
 * @description:
 * @author: 张明喆
 * @create: 2023-04-25 17:09
 **/
@Service
public class StockService_lock_syn {
    @Autowired
    private StockDao stockDao;
        //public static Object o=new Object();
        /**
         * 1.0
         */
        // 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 "库存减失败";
            }
        }
}

运行之后我们会发现，有重卖现象

同一个库存数被多个线程卖，线程安全问题。—思考:之前出现线程安全问题时如何解决。可以使用锁解决:----synchronized和Lock锁

package com.zmz.service;
import com.zmz.dao.StockDao;
import com.zmz.entity.Stock;
import org.springframework.beans.factory.annotation.Autowired;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
 * @program: redis-lock-qy145
 * @description:
 * @author: 
 * @create: 2023-04-25 21:14
 **/
public class StockService {
    @Autowired
    private StockDao stockDao;
    public static Object o=new Object();
    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都是基于JVM的本地锁。

需要在idea中跑项目的集群

然后配置nginx集群

启动window的nginx.exe
任务管理器就可以看到nginx.exe的进程

然后再次用jmeter压测（注意更换端口号）

我们可以看到集群有重卖现象

3.redis使用分布式锁

@Autowired
    private StockDao stockDao;
    private StringRedisTemplate redisTemplate;
    public  String jianStock(Integer pid){
        //占锁
        ValueOperations<String, String> forValue = redisTemplate.opsForValue();
        //占锁失败
        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);
        }
    }

如果业务代码的执行时间超过30s，当前线程删除的是其他线程的锁资源。 --watchDog机制
每个10s检测当前线程是否还持有所资源，如果持有则为当前线程延迟。—可以自己设置watchDog机制，—第三方Redission完美的解决分布式锁。

4.redisson完美解决redis超时问题

引入依赖

<dependency>
            <groupId>org.redisson</groupId>
            <artifactId>redisson</artifactId>
            <version>3.13.4</version>
        </dependency>

main函数

@Bean //创建redisson交于spring容器来管理
    public RedissonClient redisson() {
        Config config = new Config();
        config.setLockWatchdogTimeout(300);
        config.useSingleServer().setAddress("redis://192.168.1.87:6379");
        RedissonClient redisson = Redisson.create(config);
        return redisson;
    }

使用

 @Autowired
    private RedissonClient redisson;
public String jianStock(Integer pid){
    RLock lock = redisson.getLock("product" + pid);
    try {
        lock.lock(30, TimeUnit.SECONDS);//加锁: 如果程序执行是出现一次
        Stock stock = stockDao.selectById(pid);
        if (stock.getNum()>0){
            stock.setNum(stock.getNum()-1);
            stockDao.updateById(stock);
            System.out.println("库存剩余数量:" + stock.getNum());
            return "减库存成功";
        }else {
            System.out.println("库存不足");
            return "库存减失败";
        }
    }
    finally {
        lock.unlock();
    }
}

5.redis面试题

四、Redis支持的数据类型有哪些？

String 2. Hash 3.List 4.Set 5.ZSet

五、Redis为什么是单线程的？

因为Redis是基于内存的操作，CPU不是Redis的瓶颈，Redis的瓶颈最有可能是机器内存的大小或者网络带宽。既然单线程容易实现，而且CPU不会成为瓶颈，那就顺理成章地采用单线程的方案了

六、Redis真的是单线程的吗？

并不是真的单线程，比如:RDB—Bgsave时，创建一个子线程

七、Redis持久化有几种方式？

RDB:

AOF:

八、什么是缓存穿透？怎么解决？

查询的数据在数据库中不存在，缓存中也不存在，这时有可能有人恶意访问这种数据。这些请求都会访问数据库，从而出现数据库压力过大。
情景: 比如id不合法—
确实数据库中不存在。
解决: 1. 在controller加校验
2. 我们可以在缓存中存入一个空对象，但是对象的过期时间不要太长，一般不会超过5分钟。
3. 可以使用布隆过滤器。

九、怎么保证缓存和数据库数据的一致性？

设置合理的过期时间
当执行增删改时需要删除缓存数据

十、Redis，什么是缓存雪崩？怎么解决？

缓存雪崩:就是在某一时刻出现大量数据过期，而这时就有大量的请求访问该数据，这种现象叫做缓存雪崩。
什么情况下会出现大量数据过期:
项目刚刚上线
redis服务器宕机
缓存数据真实过期

解决方案:

上线前预热数据。
集群
设置过期时间时要分散设置。

十一、Redis怎么实现分布式锁？

使用redis中的setnx命令–占锁，当业务代码执行完毕后是否锁资源，而释放锁的命令是del。

十二. redis在实现分布式锁式有什么缺陷

超时问题: 业务代码执行时间超过锁时间。使用:watchDog机制。 我们使用第三方:redisson