Redis缓存、Redis分布式锁

最新推荐文章于 2022-08-07 11:06:37 发布
最新推荐文章于 2022-08-07 11:06:37 发布
阅读量352 收藏
点赞数
分类专栏： 谷粒商城
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiang_yu_pai/article/details/118712978
版权

Redis

1、加菜单进Redis缓存

@Override
    public Map<String,List<Catelog2Vo>> listTest() {
    	//从缓存查询数据
        String category = stringRedisTemplate.opsForValue().get("category");
        if(StringUtils.isEmpty(category)) {
            System.out.println("查询数据库。。。。");
            Map<String,List<Catelog2Vo>> entities = getCategoryTest();
            String s = JSON.toJSONString(entities);
            stringRedisTemplate.opsForValue().set("category",s);
            return entities;
        }
        return JSON.parseObject(category,new TypeReference<Map<String,List<Catelog2Vo>>>(){});

    }

2、加锁解决缓存击穿

缓存击穿：缓存中没有但数据库中有的数据（一般是缓存时间到期），这时由于并发用户特别多，同时读缓存没读到数据，又同时去数据库去取数据，引起数据库压力瞬间增大，造成过大压力，加锁解决。
缓存雪崩：缓存中大量数据同一时间过期，可以设置过期时间不一致
缓存穿透：大量请求不存在的数据，可以在缓存中设置null值

查看缓存，无缓存则查询数据库，并设置完缓存再解锁。
在这里插入图片描述
在这里插入图片描述

3、分布式锁

本地锁只能锁住当前服务，微服务情况下有多个服务，Redis分布式锁就是锁住Redis

①、设置过期时间

@Override
    public Map<String, List<Catelog2Vo>> listTestWithRedisLock() {
        Map<String, List<Catelog2Vo>> categoryTest = getCategoryTest();
        String s = JSON.toJSONString(categoryTest);
        //分布式加锁,设置过期时间，放在服务宕机，锁长期占不释放
        Boolean category = stringRedisTemplate.opsForValue().setIfAbsent("category", s, 300, TimeUnit.SECONDS);

        if(category){
            //加锁成功，执行业务
        }
        else{
            //加锁失败，自旋
            return listTestWithRedisLock();
        }

        return categoryTest;
    }

②、删除锁

如果业务时间太长，过期时间太短，则有可能删除了别的服务占的锁，因此应该业务做完再删除锁。

Map<String, List<Catelog2Vo>> categoryTest = getCategoryTest();
        String s = JSON.toJSONString(categoryTest);
        UUID uuid = UUID.randomUUID();
        //分布式加锁,设置过期时间，放在服务宕机，锁长期占不释放
        Boolean category = stringRedisTemplate.opsForValue().setIfAbsent("category", uuid, 300, TimeUnit.SECONDS);

        if(category){
            //加锁成功，执行业务
            //.......
            //业务执行完成，删除锁
            String category1 = stringRedisTemplate.opsForValue().get("category");
            if(!StringUtils.isEmpty(category1)&&category.equals(uuid)){
                stringRedisTemplate.delete("category");
            }
        }
        else{
            //加锁失败，自旋
            return listTestWithRedisLock();
        }

        return categoryTest;

③、lua脚本 原子性删除锁

有可能网络原因，业务完成时间为9.5秒，过期时间为10秒，当从redis传回来确定是自己的锁，想删时却删掉了其它服务占的锁。
获取值对比+对比成功删除=原子性
在这里插入图片描述

lua脚本

@Override
    public Map<String, List<Catelog2Vo>> listTestWithRedisLock() throws InterruptedException {
        Map<String, List<Catelog2Vo>> categoryTest = null;
        String uuid = UUID.randomUUID().toString();
        //分布式加锁,设置过期时间，放在服务宕机，锁长期占不释放
        Boolean lock = stringRedisTemplate.opsForValue().setIfAbsent("lock", uuid, 300, TimeUnit.SECONDS);
        if(lock){
            System.out.println("获取分布式锁成功。。。。");
            //加锁成功，执行业务
            try{
                categoryTest = listTest();
            }finally {
                //业务执行完成，删除锁
                String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
                Long execute = stringRedisTemplate.execute(new DefaultRedisScript<Long>(script, Long.class),
                        Arrays.asList("lock"), uuid);
                return categoryTest;
            }
        }
        else{
            //加锁失败，自旋
            System.out.println("获取分布式锁失败。。。。重试");
            Thread.sleep(1000);
            return listTestWithRedisLock();
        }
    }

4、Redisson

1.锁自动续期（看门狗），不用担心业务时间过长，锁被删除，宕机后30秒自动解锁

加锁（设置释放时间）

//设置过期时间的话，不会自动续期
myLock.lock(10,TimeUnit.SECONDS);

2、读写锁

/**
     * 保证一定能读到最新数据，修改期间，写锁是一个排它锁（互斥锁、独享锁），读锁是一个共享锁
     * 写锁没释放读锁必须等待
     * 读 + 读 ：相当于无锁，并发读，只会在Redis中记录好，所有当前的读锁。他们都会同时加锁成功
     * 写 + 读 ：必须等待写锁释放
     * 写 + 写 ：阻塞方式
     * 读 + 写 ：有读锁。写也需要等待
     * 只要有读或者写的存都必须等待
     * @return
     */
    @GetMapping(value = "/write")
    @ResponseBody
    public String writeValue() {
        RReadWriteLock readWriteLock = redisson.getReadWriteLock("rw-lock");
        String s=UUID.randomUUID().toString();
        RLock rLock = readWriteLock.writeLock();
        try{
            rLock.lock();
            Thread.sleep(20000);
            stringRedisTemplate.opsForValue().set("writeValue",s);
        }catch (Exception e){

        }finally {
            rLock.unlock();
        }
        return s;
    }

    @GetMapping(value = "/read")
    @ResponseBody
    public String readValue() {
        RReadWriteLock readWriteLock = redisson.getReadWriteLock("rw-lock");
        String s="";
        RLock rLock = readWriteLock.readLock();
        try{
            rLock.lock();
            Thread.sleep(10000);
            s=stringRedisTemplate.opsForValue().get("writeValue");
        }catch (Exception e){

        }finally {
            rLock.unlock();
        }
        return s;
    }

3、信号量

/**
     * 车库停车
     * 3车位
     * 信号量也可以做分布式限流
     */
    @GetMapping(value = "/park")
    @ResponseBody
    public String park() throws InterruptedException {

        RSemaphore park = redisson.getSemaphore("park");
        park.acquire();     //获取一个信号、获取一个值,占一个车位
        boolean flag = park.tryAcquire();

        if (flag) {
            //执行业务
        } else {
            return "error";
        }

        return "ok=>" + flag;
    }

    @GetMapping(value = "/go")
    @ResponseBody
    public String go() {
        RSemaphore park = redisson.getSemaphore("park");
        park.release();     //释放一个车位
        return "ok";
    }

4、缓存和数据库一致性

双写模式，失效模式
在这里插入图片描述
在这里插入图片描述
解决方案：

如果是用户纬度数据（订单数据、用户数据），这种只有用户自己发起操作,并发几率非常小，不用考虑这个问题，缓存数据加上过期时间，每隔一段时间触发读的主动更新即可
如果是菜单，商品介绍等基础数据，也可以去使用canal订阅binlog的方式
缓存数据+过期时间也足够解决大部分业务对于缓存的要求。
通过读写锁可以实现，（对于经常读写的效率就会变低）；
总结：

我们能放入缓存的数据本就不应该是实时性、一致性要求超高的。所以缓存数据的时候加上过期时间，保证每天拿到当前最新数据即可。
我们不应该过度设计，增加系统的复杂性
遇到实时性、一致性要求高的数据，就应该查数据库，即使慢点。
在这里插入图片描述

5、SpringCache

①、简化缓存的操作

1、配置依赖

<dependency>
    <groupId>org.springframework.b oot</groupId>
    <artifactId>spring-boot-starter-cache</artifactId>
</dependency>

2、指定缓存类型

spring:
  cache:
  	#指定缓存类型为redis
    type: redis
    redis:
      # 指定redis中的过期时间为1h
      time-to-live: 3600000

3、在主配置类上加上注解@EnableCaching

②、自定义内容

1、自定义ttl

# 指定redis中的过期时间为1h
      time-to-live: 3600000

2、指定缓存的key值

key = "#root.method.name"

3、配置缓存的value为json

//CacheProperties为一个配置文件类，通过@EnableConfigurationProperties可以将CacheProperties加入进容器
@EnableConfigurationProperties(CacheProperties.class)
@Configuration
@EnableCaching
public class MyCacheConfig {

    // @Autowired
    // public CacheProperties cacheProperties;

    /**
     * 配置文件的配置没有用上
     * 加入容器的方法直接用容器里的组件，不用@Autowired
     * @return
     */
    @Bean
    public RedisCacheConfiguration redisCacheConfiguration(CacheProperties cacheProperties) {

        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig();
        // config = config.entryTtl();
        //配置key,value的存储格式（GenericJackson2JsonRedisSerializer为泛型）
        config = config.serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer()));
        config = config.serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(new GenericJackson2JsonRedisSerializer()));

        CacheProperties.Redis redisProperties = cacheProperties.getRedis();
        //将配置文件中所有的配置都生效
        if (redisProperties.getTimeToLive() != null) {
            config = config.entryTtl(redisProperties.getTimeToLive());
        }
        if (redisProperties.getKeyPrefix() != null) {
            config = config.prefixKeysWith(redisProperties.getKeyPrefix());
        }
        if (!redisProperties.isCacheNullValues()) {
            config = config.disableCachingNullValues();
        }
        if (!redisProperties.isUseKeyPrefix()) {
            config = config.disableKeyPrefix();
        }

        return config;
    }

}

③、SpringCache原理与不足

1）、读模式

缓存穿透：查询一个null数据。解决方案：缓存空数据，可通过spring.cache.redis.cache-null-values=true
缓存击穿：大量并发进来同时查询一个正好过期的数据。解决方案：加锁 ? 默认是无加锁的;
使用sync = true来解决击穿问题
缓存雪崩：大量的key同时过期。解决：加随机时间。
2)、写模式：（缓存与数据库一致）

读写加锁。
引入Canal，感知到MySQL的更新去更新Redis
读多写多，直接去数据库查询就行
3）、总结：

常规数据（读多写少，即时性，一致性要求不高的数据，完全可以使用Spring-Cache）：

写模式(只要缓存的数据有过期时间就足够了)

特殊数据：特殊设计

xiang_yu_pai
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Redis 缓存 & 分布式锁
weixin_43197640的博客
03-25 324
一、缓存 1、缓存使用 为了系统性能的提升，我们一般都会将部分数据放入缓存中，加速访问。而 db 承担数据落盘工作（持久化工作），数据库查询一次后将数据存入缓存，以后需要该数据直接从缓存中取。 适合放入缓存的数据： 即时性、数据一致性要求不高的 访问量大且更新频率不高的数据（读多，写少） 缓存中存放的所有对象都应该是 JSON 字符串，JSON 跨语言、跨平台兼容。 给缓存中存放 JSON 字符串，从缓存中拿出的 JSON 字符串，还要逆转为能用的对象类型【序列化与反序列化的过程】 Demo： @O
redis做缓存和分布式锁
weixin_43529556的博客
03-29 1009
引入依赖 jedis用来连接redis客户端， <!-- 缓存 --> <dependency> <groupId>redis.clients</groupId> <artifactId>jedis</artifactId> <version>2.8.1</version> </dependency&g
Redis实现缓存与分布式锁
成名的博客
10-22 451
缓存与分布式锁 哪些数据适合放入缓存 即时性、数据一致性要求不高的 访问量大且更新频率不高的数据 选择redis做为缓存中间件 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> 问题记录与分析 产生堆外内存溢出：OutOf
redis锁和分布式锁的实现
热门推荐
sinJack的博客
10-08 3万+
redis环境搭建 redis在java、spring、springboot中的简单应用 redis锁 1、添加依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> 2、application.yml配置 sprin
redis分布式锁
qq_44300280的博客
03-27 1569
redis分布式锁
redis和redisson实现分布式锁
05-26
redis分布式锁demo。包括守护线程的锁延迟过期时间，锁竞争时的循环重试
redis分布式缓存中间件培训PPT
08-10
Redis分布式缓存中间件培训PPT Redis是完全开源免费的高性能key-value数据库，可以满足高可用、高并发的要求。Redis支持数据的持久化，可以将内存中的数据保存在磁盘中，重启的时候可以再次加载进行使用。同时，...
Redis_Redis分布式缓存_
09-30
实现Redis分布式缓存，此文件为相关原理
浅析Redis分布式锁
12-16
前期考虑的方案有采用ZooKeeper分布式任务,Quartz分布式任务调度,但是由于Zookeeper需要增加额外组件,Quartz需要增加表,并且项目中现在已经有Redis这一组件存在,所以考虑采用Redis分布式锁的情况来完成分布式任务...
SpringBoot使用Redis实现分布式锁
08-19
SpringBoot 使用 Redis 实现分布式锁是指使用 SpringBoot 框架和 Redis 缓存数据库来实现分布式锁的机制。 分布式锁的需求条件 在分布式系统中，为了保证共享资源的安全性和一致性，分布式锁需要具备以下五点条件...
redis 缓存锁的实现方法
阅读之后，对你有帮助，那就点个赞再走吧
03-19 293
1. redis加锁分类 redis能用的的加锁命令分表是INCR、SETNX、SET 2. 第一种锁命令INCR 这种加锁的思路是， key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 INCR 操作进行加一。 然后其它用户在执行 INCR 操作进行加一时，如果返回的数大于 1 ，说明这个锁正在被使用当中。 1、 客户端A请求服务器获取key的值为1表示获取了...
Redis缓存&分布式锁
lesliewongjie
08-01 454
缓存一、缓存1.缓存的使用 一、缓存 1.缓存的使用 为了系统性能的提升，我们一般都会将部分数据放入缓存中，加速访问。而db承担数据落盘工作。 哪些数据适合放入缓存? 即时性、数据一致性要求不高的 访问量大且更新频率不高的数据（读多，写少） ...
详解Redis，Redis缓存，Redis分布式锁
Java开发，人工智能，边缘计算，致力于掌握前沿技术
08-20 843
1、Redis基本知识 简介 Redis是一个支持网络、基于内存、可选持久性的NoSql数据库，目前在很多的系统中都使用了Redis，尤其是在实现缓存功能的时候应用的尤其广泛（缓存功能也是很多人对Redis的认识），那么Redis到底有哪些优点和缺点，为什么会被广泛应用呢？ Redis的优点 Redis的第一个优点就是速度快，Redis使用C语言实现，基于内存，数据的读写效率非常的高，这也是为什么...
基于Redis缓存层实现分布式锁
分享传递价值
04-03 5004
常见分布式锁实现方案 分布式锁原则 1、相互排斥，即任一时刻，只能有一个客户端持有锁; 2、无死锁，持有锁的客户端宕机或网络延迟下仍可获取锁; 3、有始有终，一个客户端加了锁，只能自己释放锁，当然也不能被其他客户端解锁; 4、容错性，只要大部分redis节点还存活，那么客户端就应该可以正常加锁和释放锁; 一、加锁操作 &lt;!--jedis 2.9.0--&gt; &lt;de...
Redis（四）缓存、分布式锁
HK的博客
10-06 1578
缓存雪崩、缓存穿透、缓存击穿、分布式锁
springboot-redis-lock-cache 使用redis分布式锁
小石潭记丶
10-03 867
1.创建springboot项目 2.pom.xml <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:sche...
Redis做分布式锁，redission，rediscache，redis面试等.....
weixin_45699541的博客
08-07 533
1）自动锁的时间续期 (2)TTL:time to live,自动设置过期时间 ,但是一旦自己设置了超时时间，会造成锁的时间不会自动续期，从而导致 当业务时间大于 锁的时间的时候，自己的锁被释放了，但是 业务还没有执行完毕，导致 其他线程占用锁而删除，可当第一个线程业务执行完毕时候删除锁的时候，删除的是第二个锁。漏洞：当1线程在 写入往redis写缓存之前卡住了，2号线程过来直接完成了双写模式，再切换1线程对缓存进行写，则2号线程是后发生的，但是缓存写进去的确是1号线程。需要指定过期时间（ttl）....
django中的redis缓存
你呢的博客
06-28 1241
首先先来说一下缓存的基本操作 from django.core.cache import cache # 设置缓存数据， version用来控制版本，不同的版本之间的数据不互通 cache.set(key, value, timeout=default_timeout, version) # 获取缓存的数据，如果设置了default，则在没有获取到改key的值时，使用default ca...
PHP缓存锁原理及利用
yshir
04-26 396
概述： 项目当中经常要考虑数据高并发的情况，为了避免并发导致出现一些资源重复请求的问题，可以使用缓存加锁机制。 例如取微信access_token不加锁可能会导致非常严重的后果。 准备： 缓存锁，顾名思义，当然离不开缓存，这篇文章用到的redis缓存，可以根据自己的需要要选择合适缓存。 缓存锁的原理是在进行操作A之前，先在缓存中存放一个唯一的key，然后就进行对应操作A，而如果同时有其他一样的操...
redis + lua 实现分布式锁逻辑
最新发布
07-13
Redis是一个开源的内存数据库，同时也是一个高效的缓存系统。Lua是一种轻量级脚本语言，可以被集成到Redis中，用于编写Redis脚本。Redis + Lua可以实现分布式锁逻辑。 下面是一个使用Redis + Lua实现分布式锁的示例代码： ``` -- 调用 Redis 的 setnx 方法设置 key 值为 lock_key 的值为当前时间戳 + 过期时间 -- 若设置成功，表示获取锁成功 -- 若设置失败，则表示获取锁失败 -- 返回值为 1 表示获取锁成功，0 表示获取锁失败 local result = redis.call('setnx', KEYS[1], ARGV[1]) if result == 1 then -- 获取锁成功，则设置锁过期时间 redis.call('expire', KEYS[1], ARGV[2]) end -- 返回获取锁的结果 return result ``` 这段代码使用 Redis 的 setnx 方法来设置 key 值为 lock_key 的值为当前时间戳 + 过期时间。若设置成功，表示获取锁成功；若设置失败，则表示获取锁失败。获取锁成功后，再设置锁的过期时间，确保锁不会一直占用。最后返回获取锁的结果。 在实际使用中，可以将上述代码封装成一个函数，方便调用。需要注意的是，分布式锁的实现还需要考虑锁的释放、锁的重入、锁的超时等问题。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值