超级详细！！！谷粒商城Redis缓存的使用笔记，涵盖分布式缓存、使用流程、分布式缓存下产生的一系列问题、分布式锁、Redisson、分布式锁与同步器、缓存数据一致性、SpringCache。

最新推荐文章于 2024-05-18 19:50:56 发布
最新推荐文章于 2024-05-18 19:50:56 发布
阅读量1.3k 收藏 11
点赞数 4
分类专栏： java 文章标签： redis java 数据库 后端 分布式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45203539/article/details/120145262
版权

 

注意：CSDN格式不太美观，原格式可以去语雀看，链接如下

https://www.yuque.com/docs/share/7a847947-f463-4a63-8027-92a7e81b90fa?# 《缓存的使用》

一、本地缓存

本地缓存的模式：

1、本地缓存在分布式下的问题

问题：

1、由于缓存是分开在多台服务器中，所以每台不同的服务器使用都需要重新查一遍。

2、数据不一致问题，假设A服务器执行了一次业务后，最新的数据已经放在A服务器中，这时B服务器接收到下次请求，读取到的数据将跟A服务器上一次保存的额数据不同。

代码实现：

本地使用一个new Map中保存的数据，下次如果使用到直接从Map中拿。

二、分布式缓存

分布式缓存的模式：

特别：

多台服务器共享同一个缓存，解决了数据共享与一致性问题。

三、使用流程（Redis）

1、引入Maven依赖

springboot2.0默认使用lettuce操作redis的客户端，这里未排除（需要排除往下看），后序引入Jedis操作Redis。

        <!-- 引入redis -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

引入Jedis

        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
        </dependency>

引入redis依赖后即可查看到redis的自动配置

2、配置Redis

spring:
  redis:
    host: 192.168.56.10
    port: 6379

3、单元测试

我们通常使用自动配置好的StringRedisTemplate来操作Redis

    @Resource
    private StringRedisTemplate stringRedisTemplate;

	    @Test
    public void testStringRedis() {
        ValueOperations<String, String> ops = stringRedisTemplate.opsForValue();

        //保存
        ops.set("hello","world_" + UUID.randomUUID().toString());

        //查询
        String hello = ops.get("hello");
        System.out.println("之前保存的数据:"+hello);
    }

可以操作各种不同的redis类型

4、代码逻辑

阶段一

问题1：堆外内存溢出

产生堆外内存溢出OutOfDirectMemoryError

1)、springboot2.0以后默认使用lettuce操作redis的客户端，它使用通信
2)、lettuce的bug导致netty堆外内存溢出 可设置：-Dio.netty.maxDirectMemory

解决方案：不能直接使用-Dio.netty.maxDirectMemory去调大堆外内存
1)、升级lettuce客户端。 2）、切换使用jedis

lettuce优势是使用Netty通信，吞吐量极大。 Jedis优在稳定，但是已经很久不更新了。

解决流程：

maven依赖排除lettuce

        <!-- 引入redis -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
            <exclusions>
                <exclusion>
                    <groupId>io.lettuce</groupId>
                    <artifactId>lettuce-core</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

引入Jedis

        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
        </dependency>

Lettuce、Jedis关系

lettuce、jedis操作redis的底层客户端。Sprinig再次封装redisTempLate，所以无论使用什么操作Redis，都直接使用RedisTemplate就可以。

阶段二

四、分布式缓存产生的问题

1、缓存穿透问题

2、缓存雪崩问题

3、缓存击穿问题

解决方案

本地锁（不适用分布式）

    public Map<String, List<Catelog2Vo>> getCatalogJsonFromDbWithLocalLock() {
        //TODO 本地锁：只锁当前进程，分布式多服务器下不适用。
        synchronized (this) {
            log.info(Thread.currentThread().getId() + "线程抢占本地synchronized锁");
            String catalogJSON = redisTemplate.opsForValue().get("catalogJSON");
            if (!StringUtils.isEmpty(catalogJSON)) {
                Map<String, List<Catelog2Vo>> result =
                        JSON.parseObject(catalogJSON, new TypeReference<Map<String, List<Catelog2Vo>>>() {
                        });
                return result;
            }
        }
        
        查询数据库逻辑
            	.............
            	getDataFromDb();	//改造方法看下面
    }

问题1：只能锁住当前进程，所以我们需要分布式锁

分布式锁第五部分内容

问题2：锁的时序问题导致一个服务器多次查询

原因：从数据中查询的数据还未在Redis中写完，后序线程又拿到锁。

解决：查询数据库放入缓存的操作应该是原子操作，在同一把锁之内。改造查询数据库方法

    private Map<String, List<Catelog2Vo>> getDataFromDb() {
        //得到锁以后，我们应该再去缓存中确定一次，如果没有才需要继续查询
        String catalogJson = stringRedisTemplate.opsForValue().get("catalogJson");
        if (!StringUtils.isEmpty(catalogJson)) {
            //缓存不为空直接返回
            Map<String, List<Catelog2Vo>> result = JSON.parseObject(catalogJson, new TypeReference<Map<String, List<Catelog2Vo>>>() {
            });

            return result;
        }

        System.out.println("查询了数据库");

        查询数据库操作
            	。。。。。。。。

            //重点！！！！！！！！！！！！
        //3、将查到的数据放入缓存,将对象转为json
        String valueJson = JSON.toJSONString(parentCid);
        stringRedisTemplate.opsForValue().set("catalogJson", valueJson, 1, TimeUnit.DAYS);

        return parentCid;
    }

五、分布式锁

问题引出

        /**
         * ！ 问题1：为了避免多个线程同时调用，所以要给方法加锁。
         * ！ 问题2：本地锁会造成分布式业务下多个线程同时占用锁并查询数据库的情况，所以采用分布式锁。
         * ！ 问题3：为了防止删除失败造成死锁，需要设置过期时间，进入if再设置依然会导致死锁问题，所以加锁与设置过期时间应该是同时的。
         * ！ 问题4：如果业务代码执行时间长于锁过期时间，就会导致多个线程同时占用锁，此时，给每个线程加一个uuid作为令牌避免删除锁的时候删除了别人的锁。
         * ！ 问题5：添加令牌后如果锁在判断成功后准备删除的时候，当前锁到期，其他线程加锁，容易误删其他线程的锁。
         * ！ 问题6：解决误删问题需要采用原子性操作删锁，因此使用redis官方提供的lua脚本删锁。
         * ！ 问题7：如果程序未执行完，锁过期了，最简单的解决方案：设置的过期时间保证大于执行时间，或者给锁续期。
         * ！ 问题8：缓存中的数据如何保持与数据库一致？
         *          缓存一致性问题：
         *              双写模式：改完数据库紧接着修改缓存。
         *                  双写模式产生脏数据？①加锁写入。 ②最终一致性，延期修改缓存数据。
         *              失效模式：删除缓存中的数据，等待下次查询进行更新。
         */

1、分布式锁的演进阶段一 --setNX方法

逻辑代码

简单方法：存在很大问题

Setnx占好了位，业务代码异常或者程序在页面过程中宕机。没有执行删除锁逻辑,这就造成了死锁

解决:

设置锁自动过期时间，即使没有删除，会自动删除。

问题依旧存在

要求加锁和设置过期时间必须是原子性的。

2、分布式锁的演进阶段二 --设置过期时间

代码逻辑

3、分布式锁的演进阶段三 --删锁问题

解决：为锁设置唯一区分的UUID标识

依然存在问题

代码逻辑

问题：

拿到Lock的时候是自己的锁，返回途中锁过期了，导致执行删除逻辑时删除了别人的锁。

所以需要保证删锁也是原子性的。 获取值对比 + 对比成功删锁 = 原子操作 （使用Lua脚本）

4、分布式锁的演进阶段四 --原子性删锁

获取值对比 + 对比成功删锁 = 原子操作 （使用Lua脚本）

官方文档

代码逻辑

String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
//删除锁	
//stringRedisTemplate.execute(new DefaultRedisScript<返回值类型>(脚本, 返回值类型0或1 ), 传入所有的Key, Key对应的值);
stringRedisTemplate.execute(new DefaultRedisScript<Long>(script, Long.class), Arrays.asList("lock"), uuid);

5、分布式锁的演进阶段五 --最终形态

问题：业务时间超长，还未执行完，锁过期了。

解决：加锁时间保证业务执行结束。

6、引入Redisson解决分布式锁

具体细节看第七部分内容

    public Map<String, List<Catelog2Vo>> getCatalogJsonFromDbWithRedissonLock() {
        //1、占分布式锁。去redis占坑
        //（锁的粒度，越细越快:具体缓存的是某个数据，11号商品） product-11-lock
        //RLock catalogJsonLock = redissonClient.getLock("catalogJson-lock");
        //创建读锁
        RReadWriteLock readWriteLock = redissonClient.getReadWriteLock("catalogJson-lock");

        RLock rLock = readWriteLock.readLock();

        Map<String, List<Catelog2Vo>> dataFromDb = null;
        try {
            rLock.lock();
            //加锁成功...执行业务
            dataFromDb = getDataFromDb();
        } finally {
            rLock.unlock();
        }
        return dataFromDb;
    }

解决完分布式锁引入一个问题就是缓存一致性问题：一旦数据修改或者删除，缓存中的数据怎么保持一致？详情看第八部分

六、Redisson

1、概述

Redisson是一个在Redis的基础上实现的Java驻内存数据网格(In-Memory Data Grid)。它不仅提供了一系列的分布式的Java常用对象，还提供了许多分布式服务。其中包括(BitSet , Set,Multimap ,SortedSet ,Map , List , Queue, BlockingQueue , Deque , BlockingDeque,Semaphore, Lock ,AtomicLong ,CountDownLatch , Publish / Subscribe,Bloom filter , Remote service , Spring cache , Executor service , Live Object service ,Scheduler service ) Redisson提供了使用Redis的最简单和最便捷的方法。Redisson的宗旨是促进使用者对Redis的关注分离(Separation of Concern),从而让使用者能够将精力更集中地放在处理业务逻辑上。

2、使用流程

引入maven依赖

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

配置RedissonClient

集群模式

@Configuration
public class MyRedissonConfig {

    /**
     * 所有对Redisson的使用都是通过RedissonClient
     * @return
     * @throws IOException
     */
    @Bean(destroyMethod="shutdown")
    public RedissonClient redisson() throws IOException {
        //1、创建配置
        Config config = new Config();
        config.useClusterServers()
                .addNodeAddress("127.0.8.1:7884","127.0.0.1:7e01");
        return Redisson.create(config);
    }

}

单节点模式

@Configuration
public class MyRedissonConfig {

    /**
     * 所有对Redisson的使用都是通过RedissonClient
     * @return
     * @throws IOException
     */
    @Bean(destroyMethod="shutdown")
    public RedissonClient redisson() throws IOException {
        //1、创建配置
        Config config = new Config();
        config.useSingleServer().setAddress("redis://192.168.56.10:6379");
        RedissonClient redissonClient = Redisson.create(config);
        return redissonClient;
    }

}

测试

只要注入对象成功就能用了

    @Test
    public void testRedisson() {
        System.out.println(redissonClient);
    }

3、商城代码逻辑

    public Map<String, List<Catelog2Vo>> getCatalogJsonFromDbWithRedissonLock() {
        //1、占分布式锁。去redis占坑
        //（锁的粒度，越细越快:具体缓存的是某个数据，11号商品） product-11-lock
        //RLock catalogJsonLock = redissonClient.getLock("catalogJson-lock");
        //创建读锁
        RReadWriteLock readWriteLock = redissonClient.getReadWriteLock("catalogJson-lock");

        RLock rLock = readWriteLock.readLock();

        Map<String, List<Catelog2Vo>> dataFromDb = null;
        try {
            rLock.lock();
            //加锁成功...执行业务
            dataFromDb = getDataFromDb();
        } finally {
            rLock.unlock();
        }
        return dataFromDb;
    }

七、Redisson分布式锁和同步器

官方文档：https://github.com/redisson/redisson/wiki/8.%E5%88%86%E5%B8%83%E5%BC%8F%E9%94%81%E5%92%8C%E5%90%8C%E6%AD%A5%E5%99%A8

1、概述

雷神注释

//1、获取一把锁，只要锁的名字一样，就是同一把锁

RLock myLock = redisson.getLock("my-lock");

//2、加锁

myLock.lock(); //阻塞式等待。默认加的锁都是30s

//1）、锁的自动续期，如果业务超长，运行期间自动锁上新的30s。不用担心业务时间长，锁自动过期被删掉

//2）、加锁的业务只要运行完成，就不会给当前锁续期，即使不手动解锁，锁默认会在30s内自动过期，不会产生死锁问题

// myLock.lock(10,TimeUnit.SECONDS); //10秒钟自动解锁,自动解锁时间一定要大于业务执行时间

//问题：在锁时间到了以后，不会自动续期

//1、如果我们传递了锁的超时时间，就发送给redis执行脚本，进行占锁，默认超时就是 我们制定的时间

//2、如果我们指定锁的超时时间，就使用 lockWatchdogTimeout = 30 * 1000 【看门狗默认时间】

//只要占锁成功，就会启动一个定时任务【重新给锁设置过期时间，新的过期时间就是看门狗的默认时间】,每隔10秒都会自动的再次续期，续成30秒

// internalLockLeaseTime 【看门狗时间】 / 3， 10s

8.1. 可重入锁（Reentrant Lock）

基于Redis的Redisson分布式可重入锁RLock Java对象实现了java.util.concurrent.locks.Lock接口。同时还提供了异步（Async）、反射式（Reactive）和RxJava2标准的接口。

RLock lock = redisson.getLock("anyLock");
// 最常见的使用方法
lock.lock();

大家都知道，如果负责储存这个分布式锁的Redisson节点宕机以后，而且这个锁正好处于锁住的状态时，这个锁会出现锁死的状态。为了避免这种情况的发生，Redisson内部提供了一个监控锁的看门狗，它的作用是在Redisson实例被关闭前，不断的延长锁的有效期。默认情况下，看门狗的检查锁的超时时间是30秒钟，也可以通过修改Config.lockWatchdogTimeout来另行指定。

另外Redisson还通过加锁的方法提供了leaseTime的参数来指定加锁的时间。超过这个时间后锁便自动解开了。

// 加锁以后10秒钟自动解锁
// 无需调用unlock方法手动解锁
lock.lock(10, TimeUnit.SECONDS);

// 尝试加锁，最多等待100秒，上锁以后10秒自动解锁
boolean res = lock.tryLock(100, 10, TimeUnit.SECONDS);
if (res) {
   try {
     ...
   } finally {
       lock.unlock();
   }
}

Redisson同时还为分布式锁提供了异步执行的相关方法：

RLock lock = redisson.getLock("anyLock");
lock.lockAsync();
lock.lockAsync(10, TimeUnit.SECONDS);
Future<Boolean> res = lock.tryLockAsync(100, 10, TimeUnit.SECONDS);

RLock对象完全符合Java的Lock规范。也就是说只有拥有锁的进程才能解锁，其他进程解锁则会抛出IllegalMonitorStateException错误。但是如果遇到需要其他进程也能解锁的情况，请使用分布式信号量Semaphore 对象.

8.2. 公平锁（Fair Lock）

基于Redis的Redisson分布式可重入公平锁也是实现了java.util.concurrent.locks.Lock接口的一种RLock对象。同时还提供了异步（Async）、反射式（Reactive）和RxJava2标准的接口。它保证了当多个Redisson客户端线程同时请求加锁时，优先分配给先发出请求的线程。所有请求线程会在一个队列中排队，当某个线程出现宕机时，Redisson会等待5秒后继续下一个线程，也就是说如果前面有5个线程都处于等待状态，那么后面的线程会等待至少25秒。

RLock fairLock = redisson.getFairLock("anyLock");
// 最常见的使用方法
fairLock.lock();

大家都知道，如果负责储存这个分布式锁的Redis节点宕机以后，而且这个锁正好处于锁住的状态时，这个锁会出现锁死的状态。为了避免这种情况的发生，Redisson内部提供了一个监控锁的看门狗，它的作用是在Redisson实例被关闭前，不断的延长锁的有效期。默认情况下，看门狗的检查锁的超时时间是30秒钟，也可以通过修改Config.lockWatchdogTimeout来另行指定。

另外Redisson还通过加锁的方法提供了leaseTime的参数来指定加锁的时间。超过这个时间后锁便自动解开了。

// 10秒钟以后自动解锁
// 无需调用unlock方法手动解锁
fairLock.lock(10, TimeUnit.SECONDS);

// 尝试加锁，最多等待100秒，上锁以后10秒自动解锁
boolean res = fairLock.tryLock(100, 10, TimeUnit.SECONDS);
...
fairLock.unlock();

Redisson同时还为分布式可重入公平锁提供了异步执行的相关方法：

RLock fairLock = redisson.getFairLock("anyLock");
fairLock.lockAsync();
fairLock.lockAsync(10, TimeUnit.SECONDS);
Future<Boolean> res = fairLock.tryLockAsync(100, 10, TimeUnit.SECONDS);

8.3. 联锁（MultiLock）

基于Redis的Redisson分布式联锁RedissonMultiLock对象可以将多个RLock对象关联为一个联锁，每个RLock对象实例可以来自于不同的Redisson实例。

RLock lock1 = redissonInstance1.getLock("lock1");
RLock lock2 = redissonInstance2.getLock("lock2");
RLock lock3 = redissonInstance3.getLock("lock3");

RedissonMultiLock lock = new RedissonMultiLock(lock1, lock2, lock3);
// 同时加锁：lock1 lock2 lock3
// 所有的锁都上锁成功才算成功。
lock.lock();
...
lock.unlock();

大家都知道，如果负责储存某些分布式锁的某些Redis节点宕机以后，而且这些锁正好处于锁住的状态时，这些锁会出现锁死的状态。为了避免这种情况的发生，Redisson内部提供了一个监控锁的看门狗，它的作用是在Redisson实例被关闭前，不断的延长锁的有效期。默认情况下，看门狗的检查锁的超时时间是30秒钟，也可以通过修改Config.lockWatchdogTimeout来另行指定。

另外Redisson还通过加锁的方法提供了leaseTime的参数来指定加锁的时间。超过这个时间后锁便自动解开了。

RedissonMultiLock lock = new RedissonMultiLock(lock1, lock2, lock3);
// 给lock1，lock2，lock3加锁，如果没有手动解开的话，10秒钟后将会自动解开
lock.lock(10, TimeUnit.SECONDS);

// 为加锁等待100秒时间，并在加锁成功10秒钟后自动解开
boolean res = lock.tryLock(100, 10, TimeUnit.SECONDS);
...
lock.unlock();

8.4. 红锁（RedLock）

基于Redis的Redisson红锁RedissonRedLock对象实现了Redlock介绍的加锁算法。该对象也可以用来将多个RLock对象关联为一个红锁，每个RLock对象实例可以来自于不同的Redisson实例。

RLock lock1 = redissonInstance1.getLock("lock1");
RLock lock2 = redissonInstance2.getLock("lock2");
RLock lock3 = redissonInstance3.getLock("lock3");

RedissonRedLock lock = new RedissonRedLock(lock1, lock2, lock3);
// 同时加锁：lock1 lock2 lock3
// 红锁在大部分节点上加锁成功就算成功。
lock.lock();
...
lock.unlock();

大家都知道，如果负责储存某些分布式锁的某些Redis节点宕机以后，而且这些锁正好处于锁住的状态时，这些锁会出现锁死的状态。为了避免这种情况的发生，Redisson内部提供了一个监控锁的看门狗，它的作用是在Redisson实例被关闭前，不断的延长锁的有效期。默认情况下，看门狗的检查锁的超时时间是30秒钟，也可以通过修改Config.lockWatchdogTimeout来另行指定。

另外Redisson还通过加锁的方法提供了leaseTime的参数来指定加锁的时间。超过这个时间后锁便自动解开了。

RedissonRedLock lock = new RedissonRedLock(lock1, lock2, lock3);
// 给lock1，lock2，lock3加锁，如果没有手动解开的话，10秒钟后将会自动解开
lock.lock(10, TimeUnit.SECONDS);

// 为加锁等待100秒时间，并在加锁成功10秒钟后自动解开
boolean res = lock.tryLock(100, 10, TimeUnit.SECONDS);
...
lock.unlock();

8.5. 读写锁（ReadWriteLock）

基于Redis的Redisson分布式可重入读写锁RReadWriteLock Java对象实现了java.util.concurrent.locks.ReadWriteLock接口。其中读锁和写锁都继承了RLock接口。

分布式可重入读写锁允许同时有多个读锁和一个写锁处于加锁状态。

RReadWriteLock rwlock = redisson.getReadWriteLock("anyRWLock");
// 最常见的使用方法
rwlock.readLock().lock();
// 或
rwlock.writeLock().lock();

大家都知道，如果负责储存这个分布式锁的Redis节点宕机以后，而且这个锁正好处于锁住的状态时，这个锁会出现锁死的状态。为了避免这种情况的发生，Redisson内部提供了一个监控锁的看门狗，它的作用是在Redisson实例被关闭前，不断的延长锁的有效期。默认情况下，看门狗的检查锁的超时时间是30秒钟，也可以通过修改Config.lockWatchdogTimeout来另行指定。

另外Redisson还通过加锁的方法提供了leaseTime的参数来指定加锁的时间。超过这个时间后锁便自动解开了。

// 10秒钟以后自动解锁
// 无需调用unlock方法手动解锁
rwlock.readLock().lock(10, TimeUnit.SECONDS);
// 或
rwlock.writeLock().lock(10, TimeUnit.SECONDS);

// 尝试加锁，最多等待100秒，上锁以后10秒自动解锁
boolean res = rwlock.readLock().tryLock(100, 10, TimeUnit.SECONDS);
// 或
boolean res = rwlock.writeLock().tryLock(100, 10, TimeUnit.SECONDS);
...
lock.unlock();

代码逻辑

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

    @GetMapping(value = "/read")
    @ResponseBody
    public String readValue() {
        String s = "";
        RReadWriteLock readWriteLock = redisson.getReadWriteLock("rw-lock");
        //加读锁
        RLock rLock = readWriteLock.readLock();
        try {
            rLock.lock();
            ValueOperations<String, String> ops = stringRedisTemplate.opsForValue();
            s = ops.get("writeValue");
            try {
                TimeUnit.SECONDS.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            rLock.unlock();
        }

        return s;
    }

8.6. 信号量（Semaphore）

基于Redis的Redisson的分布式信号量（Semaphore）Java对象RSemaphore采用了与java.util.concurrent.Semaphore相似的接口和用法。同时还提供了异步（Async）、反射式（Reactive）和RxJava2标准的接口。

RSemaphore semaphore = redisson.getSemaphore("semaphore");
semaphore.acquire();
//或
semaphore.acquireAsync();
semaphore.acquire(23);
semaphore.tryAcquire();
//或
semaphore.tryAcquireAsync();
semaphore.tryAcquire(23, TimeUnit.SECONDS);
//或
semaphore.tryAcquireAsync(23, TimeUnit.SECONDS);
semaphore.release(10);
semaphore.release();
//或
semaphore.releaseAsync();

代码逻辑

    /**
     * 车库停车
     * 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";
    }

8.7. 可过期性信号量（PermitExpirableSemaphore）

基于Redis的Redisson可过期性信号量（PermitExpirableSemaphore）是在RSemaphore对象的基础上，为每个信号增加了一个过期时间。每个信号可以通过独立的ID来辨识，释放时只能通过提交这个ID才能释放。它提供了异步（Async）、反射式（Reactive）和RxJava2标准的接口。

RPermitExpirableSemaphore semaphore = redisson.getPermitExpirableSemaphore("mySemaphore");
String permitId = semaphore.acquire();
// 获取一个信号，有效期只有2秒钟。
String permitId = semaphore.acquire(2, TimeUnit.SECONDS);
// ...
semaphore.release(permitId);

8.8. 闭锁（CountDownLatch）

基于Redisson的Redisson分布式闭锁（CountDownLatch）Java对象RCountDownLatch采用了与java.util.concurrent.CountDownLatch相似的接口和用法。

RCountDownLatch latch = redisson.getCountDownLatch("anyCountDownLatch");
latch.trySetCount(1);
latch.await();

// 在其他线程或其他JVM里
RCountDownLatch latch = redisson.getCountDownLatch("anyCountDownLatch");
latch.countDown();

2、代码逻辑

    @ResponseBody
    @GetMapping(value = "/hello")
    public String hello() {
        //1、获取一把锁，只要锁的名字一样，就是同一把锁
        RLock myLock = redisson.getLock("my-lock");
        //2、加锁
        myLock.lock();      //阻塞式等待。默认加的锁都是30s
        //1）、锁的自动续期，如果业务超长，运行期间自动锁上新的30s。不用担心业务时间长，锁自动过期被删掉
        //2）、加锁的业务只要运行完成，就不会给当前锁续期，即使不手动解锁，锁默认会在30s内自动过期，不会产生死锁问题
        // myLock.lock(10,TimeUnit.SECONDS);   //10秒钟自动解锁,自动解锁时间一定要大于业务执行时间
        //问题：在锁时间到了以后，不会自动续期
        //1、如果我们传递了锁的超时时间，就发送给redis执行脚本，进行占锁，默认超时就是 我们制定的时间
        //2、如果我们指定锁的超时时间，就使用 lockWatchdogTimeout = 30 * 1000 【看门狗默认时间】
        //只要占锁成功，就会启动一个定时任务【重新给锁设置过期时间，新的过期时间就是看门狗的默认时间】,每隔10秒都会自动的再次续期，续成30秒
        // internalLockLeaseTime 【看门狗时间】 / 3， 10s
        try {
            System.out.println("加锁成功，执行业务..." + Thread.currentThread().getId());
            try { TimeUnit.SECONDS.sleep(20); } catch (InterruptedException e) { e.printStackTrace(); }
        } catch (Exception ex) {
            ex.printStackTrace();
        } finally {
            //3、解锁  假设解锁代码没有运行，Redisson会不会出现死锁
            System.out.println("释放锁..." + Thread.currentThread().getId());
            myLock.unlock();
        }
        return "hello";
    }

八、缓存数据一致性问题

1、双写模式

2、失效模式

3、缓存数据一致性解决

Canal解决

我的商城系统采用①加过期时间、数据过期下次主动触发查询。②加分布式锁。

4、SpringCache

Spring从 3.1开始定义了org.springframework.cache.Cache和org.springframework.cache.CacheManager,接口来统一不同的缓存技术;并支持使用JCache (JSR-107）注解简化我们开发;

Cache接口为缓存的组件规范定义，包含缓存的各种操作集合;

Cache 接口下 Spring 提供了各种xxoCache..的实现﹔如RedisCache,EhCacheCache ,ConcurrentMapCache等;

每次调用需要缓存功能的方法时，Spring 会检查检查指定参数的指定的目标方法是否已经被调用过;如果有就直接从缓存中获取方法调用后的结果，如果没有就调用方法并缓存结果后返回给用户。下次调用直接从缓存中获取。

使用Spring缓存抽象时我们需要关注以下两点;

1、确定方法需要被缓存以及他们的缓存策略2、从缓存中读取之前缓存存储的数据

（1）使用流程

引入maven依赖

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-cache</artifactId>
        </dependency>
        
        。。。还需要引入redis，如果已经引入就不用引了

配置文件

我们来看SpringCache帮我们自动配置了哪些

RedisCacheConfiguration

为我们自动配好了缓存管理器

我们需要配置的 application.properties

spring.cache.type=redis

#spring.cache.cache-names=qq,... 缓存的名字，可不配置
spring.cache.redis.time-to-live=3600000

#如果指定了前缀就用我们指定的前缀，如果没有就默认使用缓存的名字作为前缀
#spring.cache.redis.key-prefix=CACHE_
spring.cache.redis.use-key-prefix=true
#是否缓存空值，防止缓存穿透
spring.cache.redis.cache-null-values=true

开启缓存功能

注解使用缓存

（2）默认行为

@Cacheable({"Category"})

代表当前方法的结果需要缓存，如果缓存中有，方法都不用调用，如果缓存中没有，会调用方法。最后将方法的结果放入缓存

默认行为

1）、如果缓存中有，方法不再调用。

2）、key默认自动生成，缓存的名字:SimpleKey[]（自主生成的key值）。

3）、缓存的value的值，默认使用jdk序列化机制，将序列化后的数据存到redis。

4）、默认时间是-1，代表永不过期。

自定义行为

1）、指定生成缓存使用的key key属性指定，接收一个Spel

2）、指定缓存的数据的存活时间 配置文档中修改存活时间

spring.cache.redis.time-to-live=3600000

3）、将数据保存为json格式 配置

Rabbit Coding
关注
  • 4
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
谷粒商城项目学习笔记（一）
weixin_44522176的博客
03-07 508
谷粒商城项目（一） 本人在b站学习“尚硅谷”的谷粒商城项目的教程。由于是学生，在阿里云申请了2个月的服务器，如果没有服务器，请安装虚拟机。 一. 安装软件 Linux安装docker 1.sudo yum install -y yum-utils device-mapper-persistent-data lvm2 //安装docker依赖包 2.sudo yum-config-manager --add-repo https://mirrors.aliyun.com/docker-ce/linux/c
redis分布式缓存中间件培训PPT
08-10
5. Redis使用了单线程架构，预防了多线程可能产生的竞争问题。 Redis可以应用于以下几个方面： 1. 缓存机制 – Redis提供了键值过期时间设置，并且也提供了灵活控制最大内存和内存溢出后的淘汰策略。 2. 排行榜...
学习笔记 谷粒02 Cloud
qq_25744257的博客
11-03 559
学习笔记，哔哩哔哩，谷粒商城，Cloud学习
SpringBoot集成Redisson分布式锁（Redis集群方式）
最新发布
weixin_42553047的博客
05-18 1033
在大多数项目中，都会使用缓存中间件，例如Redis、Memcached等，一般会选择项目适配的中间件，能够提高数据的访问速度，减轻后端服务器和数据库的压力，但在使用缓存时，又不得不考虑其线程安全问题，特别是现在大多数项目都使用了分布式架构，因此就需要对中间件进行优化和加强。
谷粒商城（三）
小草莓的博客
07-28 1775
高级篇需要的技术前提
谷粒商城-个人笔记(基础篇一)
热门推荐
知行
09-26 4万+
前后分离开发，分为内网部署和外网部署，外网是面向公众访问的，部署前端项目，可以有手机APP，电脑网页；
谷粒商城——Redisson看门狗
qq_45007794的博客
03-24 330
如果一个线程已经上锁后，在运行的过程中中断导致未释放锁从而导致其他线程无法进行，为此需要为每个锁设置自动过期时间。但是如果线程运行时间较长，可能在锁到期后还没执行完。为解决这种问题，Redisson使用。
Redis_Redis分布式缓存_
09-30
Redis，作为一个高性能的键值数据存储系统，常被用作分布式缓存，以提升应用程序的性能和响应速度。本文将深入探讨Redis分布式缓存的原理、应用及其优势。 分布式缓存是解决大型互联网应用高并发访问和大数据量存储...
分布式缓存 redis 分布式缓存
06-02
分布式缓存是现代大型互联网应用中不可或缺的一部分，它能够有效地解决数据访问的高并发和低延迟问题。Redis作为一款高性能的键值存储系统，被广泛应用于分布式缓存领域，为各种应用程序提供高效的数据缓存服务。 ...
java代码-使用java解决Redis分布式缓存安装和使用的源代码
03-19
java代码-使用java解决Redis分布式缓存安装和使用的源代码 ——学习参考资料：仅用于个人学习使用！
分布式缓存技术Redis在C#中的使用
07-06
Redis是一款开源的、高性能的键-值存储（key-value store）。它常被称作是一款数据结构服务器（data structure server）。Redis的键值可以包括字符串（strings）、哈希（hashes）、列表（lists）、集合（sets）和 ...
2020谷粒商城笔记资料，文档课件笔记+源代码（基础篇+高级篇
09-21
2020谷粒商城笔记资料，谷粒商城2020文档课件笔记+源代码（基础篇+高级篇） 谷粒商城2020文档课件笔记+源代码（基础篇+高级篇） 2020谷粒商城笔记资料（基础篇+高级篇） 尚硅谷谷粒商城笔记，很全。基础篇，高级篇基本都有总结。下完觉得好，给个好评。elasticsearch，本地事务、分布式事务及seata，nacos、gateway、sentinel、sleuth等等，都已经归好类了。
gulimall:分布式项目谷粒商城，前后端分离，前端基于Vue+ElementUI，后端基于SpringBoot+MybatisPlus+Mysql+Redis+ElasticSearch，具备商城所有功能（注册（社交登录）、登录、上架、检索、购物车、订单、支付、秒杀），项目框架由renrenfast开源项目搭建。项目中使用到SpringCache，SpringSession，Rabbitmq，SpringGateway+Nginx，Openfeign，alibaba-nacos做分布式注册中心和配置中
05-24
gulimall 分布式商城 Docker Docker安装RabbitMQ docker run --name rabbitmq -p 5672:5672 -p 15672:15672 -d rabbitmq:3.8-management Docker安装Mysql # 编写my.cnf配置文件 vim /root/docker/mysql/conf/my.cnf [mysql] # 设置mysql客户端默认字符集 default-character-set=utf8mb4 [client] # 设置mysql客户端连接服务端时默认使用的端口 port=3306 default-character-set=utf8mb4 [mysqld] # 设置3306端口 port=3306 # 允许最大连接数 max_connections=200 # 允许连接失败的次数。 max_connect
【谷粒商城之分布式锁Redisson-lock】
蛋饼吧的博客
05-07 1004
Redisson 是架设在 Redis 基础上的一个 Java 驻内存数据网格（In-Memory Data Grid）。充分的利用了 Redis 键值数据库提供的一系列优势， 基于 Java 实用工具包中常用接口，为使用者提供了一系列具有分布式特性的常用工具类。 使得原本作为协调单机多线程并发程序的工具包获得了协调分布式多机多线程并发系统的能力，大大降低了设计和研发大规模分布式系统的难度。同时结合各富特色的分布式服务，更进一步简化了分布式环境中程序相互之间的协作。
谷粒商城-docker搭建redis集群
qq_44300280的博客
03-26 1685
谷粒商城-docker搭建redis集群
结合电商模式打造校园交易平台之Redis缓存篇（全文总共13万字，超详细）
xjx666666的博客
02-09 713
上面我们解决了第一个命名问题和第二个设置存活时间问题，但是如何将数据以JSON的形式缓存到Redis呢？这涉及到修改缓存管理器的设置，CacheAutoConfiguration导入了，而中自动配置了缓存管理器RedisCacheManager，而RedisCacheManager要初始化所有的缓存，每个缓存决定使用什么样的配置，如果有，就用其已有的（把其配置信息取出赋给对应的变量），没有就用默认配置。} if(!
谷粒商城day06-docker安装Redis
JavaCoder_juejue的博客
08-17 573
还是像往常一样，su root 输入密码vagrant 以切换到root用户 1.下载redis镜像(这里不指定版本就默认下载最新版) docker pull redis 2.创建文件以做配置 mkdir -p /mydata/redis/conf touch /mydata/redis/conf/redis.conf 3.在上面添加的配置文件中添加配置信息,进行端口映射，命名以及目录挂载,及启动时默认加载配置文件的设置 docker run -p 6379:6379 --nam...
学习笔记 谷粒01 搭建
qq_25744257的博客
11-02 245
学习笔记
谷粒商城笔记+踩坑（12）——缓存与分布式锁，Redisson+缓存数据一致性
vincewm的博客
03-28 3021
缓存与分布式锁、Redisson分布式锁、缓存数据一致性【必须满足最终一致性】

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Rabbit Coding

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值