redis(五)

最新推荐文章于 2023-12-26 21:14:58 发布
最新推荐文章于 2023-12-26 21:14:58 发布
阅读量152 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/X_Q_B_J/article/details/104758577
版权

1、高并发下火车买票问题的分析

代码1：

public void produceStock1(){
        //1.在redis中把票数存好
        //2.从redis中获取票数
        int stock = Integer.parseInt(stringRedisTemplate.opsForValue().get("trainTickets"));
        //判断票数是否大于0
        if(stock>0){
            //票数减一
            int rStock = stock - 1;
            //将当前票数存进redis
            stringRedisTemplate.opsForValue().set("trainTickets",String.valueOf(rStock));
            logger.info("扣减库存成功。。剩余库存"+rStock);
        }else{  //说明票数不足
            logger.info("库存扣减失败，库存不足");
        }
    }

 分析：这里简单模拟了一下火车买票的场景，当程序执行时，库存会相应减一。但是明显会出现超卖现象，前面的人库存还没来得及减一，后面的人已经开始买了。解决办法如下：

public void produceStock1(){
        //1.在redis中把票数存好
        //2.从redis中获取票数
        int stock = Integer.parseInt(stringRedisTemplate.opsForValue().get("trainTickets"));
        //判断票数是否大于0
        if(stock>0){
            //票数减一
            int rStock = stock - 1;
            //将当前票数存进redis
            stringRedisTemplate.opsForValue().set("trainTickets",String.valueOf(rStock));
            logger.info("扣减库存成功。。剩余库存"+rStock);
        }else{  //说明票数不足
            logger.info("库存扣减失败，库存不足");
        }
    }

synchronized在单体应用上或许没问题，但是在分布式上面却锁不住

public synchronized String produceStock3(){
        //设置一个字符串
        String lock = "lock";
        Boolean aBoolean = stringRedisTemplate.opsForValue().setIfAbsent(lock, "");
        if(!aBoolean){
            return "排队人数过多，请稍后重试";
        }
        //1.在redis中把票数存好
        //2.从redis中获取票数
        int stock = Integer.parseInt(stringRedisTemplate.opsForValue().get("trainTickets"));
        //判断票数是否大于0
        if(stock>0){
            //票数减一
            int rStock = stock - 1;
            //将当前票数存进redis
            stringRedisTemplate.opsForValue().set("trainTickets",String.valueOf(rStock));
            logger.info("扣减库存成功。。剩余库存"+rStock);
        }else{  //说明票数不足
            logger.info("库存扣减失败，库存不足");
        }
        return "买票成功";
    }

这里又有另外一个问题，当第一个人执行完的时候，后面的人都执行不了，所以前面的人执行完之后一定要把lock删除，后面的人才可以执行

public synchronized String produceStock4(){
        //设置一个字符串
        String lock = "lock";

        try {
            Boolean aBoolean = stringRedisTemplate.opsForValue().setIfAbsent(lock, "");
            if(!aBoolean){
                return "排队人数过多，请稍后重试";
            }
            //1.在redis中把票数存好
            //2.从redis中获取票数
            int stock = Integer.parseInt(stringRedisTemplate.opsForValue().get("trainTickets"));
            //判断票数是否大于0
            if(stock>0){
                //票数减一
                int rStock = stock - 1;
                //将当前票数存进redis
                stringRedisTemplate.opsForValue().set("trainTickets",String.valueOf(rStock));
                logger.info("扣减库存成功。。剩余库存"+rStock);
            }else{  //说明票数不足
                logger.info("库存扣减失败，库存不足");
            }
        } finally {
        	//执行完把key删除
            stringRedisTemplate.delete(lock);
        }
        return "买票成功";
    }

如果第一个人在执行到一半的时候服务器宕机了，lock还没来得及删除，就发生了死锁问题，所以可以给lock设置一个过期时间

public synchronized String produceStock5(){
        //设置一个字符串
        String lock = "lock";

        try {
            Boolean aBoolean = stringRedisTemplate.opsForValue().setIfAbsent(lock, "");
            //给key设置过期时间
            stringRedisTemplate.expire(lock,30, TimeUnit.SECONDS);
            if(!aBoolean){
                return "排队人数过多，请稍后重试";
            }
            //1.在redis中把票数存好
            //2.从redis中获取票数
            int stock = Integer.parseInt(stringRedisTemplate.opsForValue().get("trainTickets"));
            //判断票数是否大于0
            if(stock>0){
                //票数减一
                int rStock = stock - 1;
                //将当前票数存进redis
                stringRedisTemplate.opsForValue().set("trainTickets",String.valueOf(rStock));
                logger.info("扣减库存成功。。剩余库存"+rStock);
            }else{  //说明票数不足
                logger.info("库存扣减失败，库存不足");
            }
        } finally {
        	//执行完把key删除
            stringRedisTemplate.delete(lock);
        }
        return "买票成功";
    }

我们可以将.setIfAbent和expire方法写出一条语句使其具有原子性

public synchronized String produceStock6(){
        //设置一个字符串
        String lock = "lock";

        try {
            //Boolean aBoolean = stringRedisTemplate.opsForValue().setIfAbsent(lock, "");
            //给key设置过期时间
            //stringRedisTemplate.expire(lock,30, TimeUnit.SECONDS);
            Boolean aBoolean = stringRedisTemplate.opsForValue().setIfAbsent(lock,"", 30, TimeUnit.SECONDS);
            if(!aBoolean){
                return "排队人数过多，请稍后重试";
            }
            //1.在redis中把票数存好
            //2.从redis中获取票数
            int stock = Integer.parseInt(stringRedisTemplate.opsForValue().get("trainTickets"));
            //判断票数是否大于0
            if(stock>0){
                //票数减一
                int rStock = stock - 1;
                //将当前票数存进redis
                stringRedisTemplate.opsForValue().set("trainTickets",String.valueOf(rStock));
                logger.info("扣减库存成功。。剩余库存"+rStock);
            }else{  //说明票数不足
                logger.info("库存扣减失败，库存不足");
            }
        } finally {
            stringRedisTemplate.delete(lock);
        }
        return "买票成功";
    }

当第一个线程还没执行完的时候已经超过过期时间，这是时候lock已经被过期了，等第一个线程执行完删除的却是第二个的锁，所以每次执行的时候给每个线程生成一个唯一值，每次删除的时候再判断一下

public synchronized String produceStock7(){
        //设置一个字符串
        String lock = "lock";
        //生成id
        String value = UUID.randomUUID().toString();
        try {
            //Boolean aBoolean = stringRedisTemplate.opsForValue().setIfAbsent(lock, "");
            //给key设置过期时间
            //stringRedisTemplate.expire(lock,30, TimeUnit.SECONDS);
            Boolean aBoolean = stringRedisTemplate.opsForValue().setIfAbsent(lock,value, 30, TimeUnit.SECONDS);
            if(!aBoolean){
                return "排队人数过多，请稍后重试";
            }
            //1.在redis中把票数存好
            //2.从redis中获取票数
            int stock = Integer.parseInt(stringRedisTemplate.opsForValue().get("trainTickets"));
            //判断票数是否大于0
            if(stock>0){
                //票数减一
                int rStock = stock - 1;
                //将当前票数存进redis
                stringRedisTemplate.opsForValue().set("trainTickets",String.valueOf(rStock));
                logger.info("扣减库存成功。。剩余库存"+rStock);
            }else{  //说明票数不足
                logger.info("库存扣减失败，库存不足");
            }
        } finally {
            //判断一下值是否相等
            if(value.equals(stringRedisTemplate.opsForValue().get(lock))){
                stringRedisTemplate.delete(lock);
            }
        }
        return "买票成功";
    }

当程序还没执行完，已经超过过期时间，这里时间设置有问题，所以我们可以使用守护线程续命

public synchronized String produceStock8(){
        //设置一个字符串
        String lock = "lock";
        //生成id
        String value = UUID.randomUUID().toString();
        try {
            //Boolean aBoolean = stringRedisTemplate.opsForValue().setIfAbsent(lock, "");
            //给key设置过期时间
            //stringRedisTemplate.expire(lock,30, TimeUnit.SECONDS);
            Boolean aBoolean = stringRedisTemplate.opsForValue().setIfAbsent(lock,value, 30, TimeUnit.SECONDS);
            if(!aBoolean){
                return "排队人数过多，请稍后重试";
            }

            //开一个守护线程,每隔过期时间的三分之一就进行续命
            MyThread myThread = new MyThread(lock);
            myThread.setDaemon(true);
            myThread.start();
            //1.在redis中把票数存好
            //2.从redis中获取票数
            int stock = Integer.parseInt(stringRedisTemplate.opsForValue().get("trainTickets"));
            //判断票数是否大于0
            if(stock>0){
                //票数减一
                int rStock = stock - 1;
                //将当前票数存进redis
                stringRedisTemplate.opsForValue().set("trainTickets",String.valueOf(rStock));
                logger.info("扣减库存成功。。剩余库存"+rStock);
            }else{  //说明票数不足
                logger.info("库存扣减失败，库存不足");
            }
        } finally {
            //判断一下值是否相等
            if(value.equals(stringRedisTemplate.opsForValue().get(lock))){
                stringRedisTemplate.delete(lock);
            }
        }
        return "买票成功";
    }


    class MyThread extends Thread{
        String lock;
        public MyThread(String lock){
            this.lock = lock;
        }

        @Override
        public void run() {
            while (true){
                try {
                    Thread.sleep(10000);
                } catch (Exception e){

                }
                //假设线程还活着，那么说明需要续命
                stringRedisTemplate.expire(lock,30,TimeUnit.SECONDS);
            }
        }
    }

2、基于Redis的分布式锁问题Redisson的简单使用

这个框架就解决了分布式锁的问题
1.导包

<!--导入redssion依赖-->
<dependency>
     <groupId>org.redisson</groupId>
     <artifactId>redisson</artifactId>
     <version>3.11.0</version>
 </dependency>

2.编写配置文件

@SpringBootConfiguration
public class RedisConfig {

    private Logger logger = LoggerFactory.getLogger(getClass());

    @Bean
    public RedissonClient redissonClient(){
        RedissonClient redissonClient = null;
        //获取config的实例
        Config config = new Config();
        //设置请求的url地址
        String url = "redis://114.55.219.117:6379";
        //设置config
        config.useSingleServer().setAddress(url);
        //通过Redisson创建一个客户端对象
        try {
            redissonClient = Redisson.create(config);
            logger.info("创建RedissonClient成功");
            return redissonClient;
        } catch (Exception e){
            logger.info("创建RedissonClient失败");
            return null;
        }
    }
}

3.编写lock的类

@Component
public class DistributeRedisLock {

    private Logger logger = LoggerFactory.getLogger(getClass());

    @Autowired
    private RedissonClient redissonClient;

    /**
     * 加锁
     * @return
     */
    public boolean lock(String lockName){
        try {
            if(null==redissonClient){
                logger.info("注入redissonClient对象失败");
                return false;
            }
            //获取这个锁
            RLock lock = redissonClient.getLock(lockName);
            lock.lock(30, TimeUnit.SECONDS);
            logger.info("加锁成功");
            return true;
        } catch (Exception e) {
            logger.info("出现异常加锁失败");
            return false;
        }
    }

    /**
     * 释放锁
     * @return
     */
    public boolean unlock(String lockName){
        try {
            if(null==redissonClient){
                logger.info("释放锁失败"+lockName);
                return false;
            }
            //获取这个锁
            RLock lock = redissonClient.getLock(lockName);
            if(null!=lock){
                lock.unlock();
                logger.info("释放锁成功");
                return true;
            }
            return false;
        } catch (Exception e) {
            logger.info("释放锁失败");
            return false;
        }
    }
}

4.调用

public synchronized String produceStockRedisson(){
        String lock = "lock";
        try {
            boolean lock1 = distributeRedisLock.lock(lock);
            if(lock1){  //说明加锁成功
                int stock = Integer.parseInt(stringRedisTemplate.opsForValue().get("trainTickets"));
                //判断票数是否大于0
                if(stock>0){
                    //票数减一
                    int rStock = stock - 1;
                    //将当前票数存进redis
                    stringRedisTemplate.opsForValue().set("trainTickets",String.valueOf(rStock));
                    logger.info("扣减库存成功。。剩余库存"+rStock);
                }else{  //说明票数不足
                    logger.info("库存扣减失败，库存不足");
                }
            }else {
                return "当前排队人数过多";
            }

        } finally {
            distributeRedisLock.unlock(lock);
        }
        return "买票成功";
    }

3、SpringBoot整合下的键值序列化

键值序列化简单来说就是key和valu存储在redis中的形式
自定义序列化器：

public class BoBoSerializer implements RedisSerializer {

    private Class aClass;

    public BoBoSerializer(Class aClass){
        this.aClass = aClass;
    }

    /**
     * 序列化
     * @param o
     * @return
     * @throws SerializationException
     */
    @Override
    public byte[] serialize(Object o) throws SerializationException {
        if(null==o){
            return null;
        }
        //将值转换为json对象
        String s = JSON.toJSONString(o);
        return s.getBytes(Charset.forName("UTF-8"));
    }

    /**
     * 反序列化
     * @param bytes
     * @return
     * @throws SerializationException
     */
    @Override
    public Object deserialize(byte[] bytes) throws SerializationException {
        if(null==bytes){
            return null;
        }
        String result = new String(bytes);
        //将json转换为Java对象
        return JSON.parseObject(result,aClass);
    }
}

2.编写配置文件

@Bean
    public RedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory){
        RedisTemplate<Object, Object> redisTemplate = new RedisTemplate<>();
        //设置连接工厂
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        //设置键的序列化器
        redisTemplate.setStringSerializer(new StringRedisSerializer());
        //设置值的序列化器
        redisTemplate.setValueSerializer(new BoBoSerializer(Object.class));
        return redisTemplate;
    }

测试:

redisTemplate.opsForValue().set("user",new User(1,"xbb","123"));

在这里插入图片描述

4、Redis开发中常见问题

1、Redis的缓存穿透

后台获取数据首先去redis中查询，redis中没有，然后去数据库中查询，发现没有，这样的话，每一个线程进来都会访问数据库，这样数据库就容易崩溃，这种问题就叫缓存穿透
在这里插入图片描述
解决方案：假设第一个线程没找到的时候，将数据库中的值设为""，并且同步到redis中，这样后面的线程访问的时候就不会进入数据库了

2、缓存雪崩

缓存雪崩是指，缓存层出现了错误，不能正常工作了。于是所有的请求都会达到存储层，存储层的调用量会暴增，造成存储层也会挂掉的情况。也就是redis挂了，所有请求都到数据库去了。指在某一个时间段，缓存集中过期失效
解决方案：

  • 在计算出key过期时间之后，动态加上一个范围内的随机数，作为key的最终过期时间，错峰过期
  • 做缓存的高可用
  • 缓存做一个降级处理
  • 做redis的缓存预热
3、redis脑裂

 客户端向主服务器写入了数据 但是主服务器还没有来得及同步的情况下 主服务器死了 那么这个时候就会选举新的主服务器 原来的主服务器在一段时间之后 又好了 那么这个时候 原来的主服务器 只能作为从服务器了 原来主服务器的数据 没有办法进行同步 这种问题 就是redis的脑裂问题
解决方案:

min-slaves-to-write 1:在我们客户端写入数据的时候 至少保证 主服务器上有一个从服务器 处于正常连接才能写入这个数据
min-slaves-max-lag 10 ：主从同步的时间 10s
X_Q_B_J
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Redis实现分布式锁
fourforfo的博客
07-28 4325
使用Redis的SETNX指令实现分布式锁，以及使用Redisson框架提供的分布式锁
java when thenreturn,Mockito when().thenReturn不必要地调用该方法
weixin_39659837的博客
02-16 747
I'm working a bit on an inherited code.I've written a test that is supposed to catch NullPointerException (for it is trying to call a method from null object)@Test(expected=NullPointerException.class)...
redis setIfAbsent的使用
hjseo_seg的博客
03-23 4959
如果为空就set值，并返回1 如果存在(不为空)不进行操作，并返回0 很明显，比get和set要好。因为先判断get，再set的用法，有可能会重复set值。 setIfAbsent 和 setnx setIfAbsent 是java中的方法 setnx 是 redis命令中的方法 setnx 例子 redis> SETNX mykey "Hello" (integer) 1 redis> SETNX mykey "World" (integer) 0 redis> GET mykey "H
setIfAbsent升级版，加了超时时间
热门推荐
weixin_37924923的博客
12-17 3万+
文章目录lua脚本封装为方法 由于业务需要使用分布式锁，使用的是redisTemplete客户端，里面有一个setIfAbsent没有带超时时间的属性，为了原子性以及操作效率，因此封装一个带超时时间的setIfAbsent lua脚本 /** redisUtil.setIfAbsent 新加的带有超时的setIfAbsent 脚本*/ String newSetIfAbsentScriptStr ...
RedisTemplate opsForValue()的 setIfAbsent() 和 getAndSet()
weixin_44163891的博客
04-24 1万+
RedisTemplate opsForValue() setIfAbsent() getAndSet()
Redis(五)
weixin_38380811的博客
10-10 438
BigKey通常以Key的大小和Key中成员的数量来综合判定，例如:·Key本身的数据量过大:一个String类型的Key，它的值为5MB。Key中的成员数过多:一个ZSET类型的Key，它的成员数量为10,000个。Key中成员的数据量过大:一个Hash类型的Key，它的成员数量虽然只有1,000个但这些成员的Value(值)总大小为100 MB。单个key的value小于10KB对于集合类型的key，建议元素数量小于1000。
Redis（四）
weixin_50458070的博客
11-20 420
黑马redis
redis五种数据类型的使用场景
07-25
综上所述，Redis的五种数据类型各有其特点和适用场景。在实际应用中，可以根据具体需求选择最合适的数据类型来存储和操作数据。同时，掌握每种数据类型的实现方式和操作细节对于优化程序性能、提升数据处理效率也是...
redis五大数据结构操作指令详细说明
10-20
Redis 五大数据结构操作指令详细说明 Redis 是一个开源的、基于内存的数据结构存储系统，可以用作数据库、消息队列、缓存等。Redis 中有五种基本数据结构，分别是 String、List、Set、Hash 和 ZSet。每种数据结构...
一文读懂redis五大类型.pdf
04-26
Redis是一个使用C语言编写的开源、支持网络、基于内存、可选持久性的键值存储数据库系统。它是一个典型的键值对存储系统，其核心特点是数据都在内存中处理，能够实现极高的性能，且它采用单线程模型处理命令请求，...
php 操作redis五大数据类型实例
06-06
本资源主要是php 操作redis五大数据类型的实例，供参考 redis安装请移步 https://blog.csdn.net/xxs18326183038/article/details/80599080
Java redis五种数据类型在Java中的详细使用
09-28
总结：本教程详细介绍了Redis的五种数据类型在Java中的应用，包括字符串、哈希、列表、集合和有序集合。通过实例代码展示了如何使用Jedis API进行增删查改操作。对于Java开发者来说，掌握这些内容对于提升项目中的...
16.Redis 高级数据类型 + 网站数据统计
m0_72161237的博客
12-26 1126
个人论坛系统：spring + spring boot + spring mvc + mybatis + redis + kafka + elasticsearch
Redis结合异步提高并发能力
chenniorange的博客
08-03 158
如下图所示的业务场景，用户向服务器提交购买优惠券的请求，服务器现在按顺序串行同步执行业务流程，这样业务虽然可以严谨执行，但是由于整个串行执行的时间耗费很长，特别是“减库存”和“创建订单”还是向MySQL中写的操作，这样一个线程就不得不按流程走完这个用户提交的请求才能去响应其它用户的请求。这里我们就可以想到多线程结合速度更快的Redis的思路，那把哪些业务交给Redis的线程呢？我们可以给每个业务都独立开新线程吗？显然也是不行的，如果开这么多线程一旦用户请求多起来，线程池中的线程很快就用完了。
redis事务中setIfAbsent无法及时返回true或false，返回null
weixin_48484941的博客
01-05 7167
代码如下，现需要批量处理业务，为了防止一条数据被多次处理，故缓存到redis中。又因可以同时操作多条数据，故考虑用redis事务，当其中一个已被其他人处理中时，之前设置的也全部回滚。但实际过程中 redisOperations.opsForValue().setIfAbsent();并非返回true或false。需要等到exec时才能获取返回值。故一下做法就无效了，需要换一种实现方式。 RedisTemplate redisTemplate = RedisUtils.getRedisTemplate()
redis setIfAbsent
m0_53373211的博客
12-14 2784
Boolean b= redisTemplate.opsForValue().setIfAbsent (Object key, Object value, Long timeout, TimeUnit unit); 如果key存在, 则不赋值 如果key不存在, 则创建并赋值
setIfAbsent(K key, V value)
Wow 五六 !!! 的博客
04-06 9502
setIfAbsent(K key, V value) 如果键不存在则新增,存在则不改变已经有的值。 如果为空就set值，并返回1 如果存在(不为空)不进行操作，并返回0
基于ssm和vue的 校园短期闲置资源置换平台源码 校园短期闲置资源置换平台代码（高分毕设项目源码）
最新发布
08-23
1. 校园短期闲置资源置换平台代码说明：经导师指导并认可通过的98分毕设项目代码。 2.适用对象：本代码学习资料适用于计算机、电子信息工程、数学等专业正在做毕设的学生，需要项目实战练习的学习者，也适用于课程设计、期末大作业。 3.技术栈：前端是vue，后端是ssm，项目代码都经过严格调试，代码没有任何bug！ 4. 作者介绍：大厂码农，java领域创作者，阿里云开发社区乘风者计划专家博主，专注于大学生项目实战开发，文章底部有博主联系方式，更多优质系统、项目定制请私信。 5. 最新计算机软件毕业设计选题大全: https://blog.csdn.net/weixin_45630258/article/details/135901374
Redis五种类型与分布式锁探索：Tedu五阶段实践
1. Redis五种数据类型及应用场景： - String：字符串类型是最基础的类型，可存储字符串、数字等，常用于存储用户ID、计数器等。 - List：列表类型，可以看作是一个有序的字符串集合，适合实现消息队列。 - Set：...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值