Redis缓存相关的几个问题

1  缓存穿透
问题描述

缓存穿透是指查询一个一定不存在的数据，由于缓存是不命中时需要从数据库查询，查不到数据则不写入缓存，这将导致这个不存在的数据每次请求都要到数据库去查询，进而给数据库带来压力。
解决方案

缓存空值，即对于不存在的数据，在缓存中放置一个空对象（注意，设置过期时间）
2  缓存击穿
问题描述

缓存击穿是指热点key在某个时间点过期的时候，而恰好在这个时间点对这个Key有大量的并发请求过来，从而大量的请求打到数据库。
解决方案

加互斥锁，在并发的多个请求中，只有第一个请求线程能拿到锁并执行数据库查询操作，其他的线程拿不到锁就阻塞等着，等到第一个线程将数据写入缓存后，直接走缓存。
3  缓存雪崩
问题描述

缓存雪崩是指缓存中数据大批量到过期时间，而查询数据量巨大，引起数据库压力过大甚至down机。
解决方案

可以给缓存的过期时间时加上一个随机值时间，使得每个 key 的过期时间分布开来，不会集中在同一时刻失效。
4  缓存服务器宕机
问题描述

并发太高，缓存服务器连接被打满，最后挂了
解决方案

• 限流：nginx、spring cloud gateway、sentinel等都支持限流
  
• 增加本地缓存（JVM内存缓存），减轻redis一部分压力
  

5  Redis实现分布式锁
问题描述

如果用redis做分布式锁的话，有可能会存在这样一个问题：key丢失。比如，master节点写成功了还没来得及将它复制给slave就挂了，于是slave成为新的master，于是key丢失了，后果就是没锁住，多个线程持有同一把互斥锁。
解决方案

必须等redis把这个key复制给所有的slave并且都持久化完成后，才能返回加锁成功。但是这样的话，对其加锁的性能就会有影响。
zookeeper同样也可以实现分布式锁。在分布式锁的的实现上，zookeeper的重点是CP，redis的重点是AP。因此，要求强一致性就用zookeeper，对性能要求比较高的话就用redis
5  示例代码
pom.xml

1. <?xml version="1.0" encoding="UTF-8"?>
2. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
3.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
4.     <modelVersion>4.0.0</modelVersion>
5.     <parent>
6.         <groupId>org.springframework.boot</groupId>
7.         <artifactId>spring-boot-starter-parent</artifactId>
8.         <version>2.6.7</version>
9.         <relativePath/>
10.     </parent>
11.     <groupId>com.example</groupId>
12.     <artifactId>demo426</artifactId>
13.     <version>0.0.1-SNAPSHOT</version>
14.     <name>demo426</name>
15.     <properties>
16.         <java.version>1.8</java.version>
17.     </properties>
18.     <dependencies>
19.         <dependency>
20.             <groupId>org.springframework.boot</groupId>
21.             <artifactId>spring-boot-starter-web</artifactId>
22.         </dependency>
23.         <dependency>
24.             <groupId>org.springframework.boot</groupId>
25.             <artifactId>spring-boot-starter-data-redis</artifactId>
26.         </dependency>
27.         <dependency>
28.             <groupId>org.redisson</groupId>
29.             <artifactId>redisson</artifactId>
30.             <version>3.17.1</version>
31.         </dependency>
32.         <dependency>
33.             <groupId>com.github.ben-manes.caffeine</groupId>
34.             <artifactId>caffeine</artifactId>
35.             <version>2.9.2</version>
36.         </dependency>
37.         <dependency>
38.             <groupId>com.alibaba</groupId>
39.             <artifactId>fastjson</artifactId>
40.             <version>2.0.1</version>
41.         </dependency>
42.         <dependency>
43.             <groupId>org.apache.commons</groupId>
44.             <artifactId>commons-lang3</artifactId>
45.             <version>3.12.0</version>
46.         </dependency>
47.         <dependency>
48.             <groupId>org.projectlombok</groupId>
49.             <artifactId>lombok</artifactId>
50.             <optional>true</optional>
51.         </dependency>
52.         <dependency>
53.             <groupId>org.springframework.boot</groupId>
54.             <artifactId>spring-boot-starter-test</artifactId>
55.             <scope>test</scope>
56.         </dependency>
57.     </dependencies>
58.     <build>
59.         <plugins>
60.             <plugin>
61.                 <groupId>org.springframework.boot</groupId>
62.                 <artifactId>spring-boot-maven-plugin</artifactId>
63.                 <configuration>
64.                     <excludes>
65.                         <exclude>
66.                             <groupId>org.projectlombok</groupId>
67.                             <artifactId>lombok</artifactId>
68.                         </exclude>
69.                     </excludes>
70.                 </configuration>
71.             </plugin>
72.         </plugins>
73.     </build>
74. </project>

复制代码

Product.java

1. package com.example.demo426.domain;
3. import lombok.Data;
5. import java.io.Serializable;
6. import java.time.LocalDateTime;
8. /**
9. * @Author ChengJianSheng
10. * @Date 2022/4/26
11. */
12. @Data
13. public class Product implements Serializable {
15.     private Long productId;
17.     private String productName;
19.     private Integer stock;
21.     private LocalDateTime createTime;
23.     private LocalDateTime updateTime;
25.     private Integer isDeleted;
27.     private Integer version;
28. }

复制代码

ProductController.java

1. package com.example.demo426.controller;
3. import com.alibaba.fastjson.JSON;
4. import com.example.demo426.domain.Product;
5. import com.example.demo426.service.ProductService;
6. import com.github.benmanes.caffeine.cache.Cache;
7. import com.github.benmanes.caffeine.cache.Caffeine;
8. import org.apache.commons.lang3.StringUtils;
9. import org.redisson.api.RLock;
10. import org.redisson.api.RReadWriteLock;
11. import org.redisson.api.RedissonClient;
12. import org.springframework.beans.factory.annotation.Autowired;
13. import org.springframework.data.redis.core.StringRedisTemplate;
14. import org.springframework.web.bind.annotation.*;
16. import javax.annotation.Resource;
17. import java.time.Duration;
18. import java.util.Random;
19. import java.util.concurrent.TimeUnit;
21. /**
22. * @Author ChengJianSheng
23. * @Date 2022/4/26
24. */
25. @RestController
26. @RequestMapping("/product")
27. public class ProductController {
29.     @Autowired
30.     private RedissonClient redissonClient;
31.     @Resource
32.     private StringRedisTemplate stringRedisTemplate;
33.     @Autowired
34.     private ProductService productService;
36.     private final Cache<long, product=""> PRODUCT_LOCAL_CACHE = Caffeine.newBuilder()
37.             .maximumSize(100)
38.             .expireAfterWrite(Duration.ofMinutes(60))
39.             .build();
41.     private final String PRODUCT_CACHE_PREFIX = "cache:product:";
42.     private final String PRODUCT_LOCK_PREFIX = "lock:product:";
43.     private final String PRODUCT_RW_LOCK_PREFIX = "lock:rw:product:";
45.     /**
46.      * 更新
47.      * 写缓存的方式有这么几种：
48.      * 1. 更新完数据库后，直接删除缓存
49.      * 2. 更新完数据库后，主动更新缓存
50.      * 3. 更新完数据库后，发MQ消息，由消费者去刷新缓存
51.      * 4. 利用canal等工具，监听MySQL数据库binlog，然后去刷新缓存
52.      */
53.     @PostMapping("/update")
54.     public void update(@RequestBody Product productDTO) {
55.         RReadWriteLock readWriteLock = redissonClient.getReadWriteLock(PRODUCT_RW_LOCK_PREFIX + productDTO.getProductId());
56.         RLock wLock = readWriteLock.writeLock();
57.         wLock.lock();
58.         try {
59.             //  写数据库
60.             //  update product set name=xxx,...,version=version+1 where id=xx and version=xxx
61.             Product product = productService.update(productDTO);
62.             //  放入缓存
63.             PRODUCT_LOCAL_CACHE.put(product.getProductId(), product);
64.             stringRedisTemplate.opsForValue().set(PRODUCT_CACHE_PREFIX + product.getProductId(), JSON.toJSONString(product), getProductTimeout(60), TimeUnit.MINUTES);
65.         } finally {
66.             wLock.unlock();
67.         }
68.     }
70.     /**
71.      * 查询
72.      */
73.     @GetMapping("/query")
74.     public Product query(@RequestParam("productId") Long productId) {
75.         //  1. 尝试从缓存读取
76.         Product product = getProductFromCache(productId);
77.         if (null != product) {
78.             return product;
79.         }
80.         //  2. 准备从数据库中加载
81.         //  互斥锁
82.         RLock lock = redissonClient.getLock(PRODUCT_LOCK_PREFIX + productId);
83.         lock.lock();
84.         try {
85.             //  再次先查缓存
86.             product = getProductFromCache(productId);
87.             if (null != product) {
88.                 return product;
89.             }
91.             //  为了避免缓存与数据库双写不一致
92.             //  读写锁
93.             RReadWriteLock readWriteLock = redissonClient.getReadWriteLock(PRODUCT_RW_LOCK_PREFIX + productId);
94.             RLock rLock = readWriteLock.readLock();
95.             rLock.lock();
96.             try {
97.                 //  查数据库
98.                 product = productService.getById(productId);
99.                 if (null == product) {
100.                     //  如果数据库中没有，则放置一个空对象，这样做是为了避免”缓存穿透“问题
101.                     product = new Product();
102.                 } else {
103.                     PRODUCT_LOCAL_CACHE.put(productId, product);
104.                 }
105.                 //  放入缓存
106.                 stringRedisTemplate.opsForValue().set(PRODUCT_CACHE_PREFIX + productId, JSON.toJSONString(product), getProductTimeout(60), TimeUnit.MINUTES);
107.             } finally {
108.                 rLock.unlock();
109.             }
110.         } finally {
111.             lock.unlock();
112.         }
114.         return null;
115.     }
117.     /**
118.      * 查缓存
119.      */
120.     private Product getProductFromCache(Long productId) {
121.         //  1. 尝试从本地缓存读取
122.         Product product = PRODUCT_LOCAL_CACHE.getIfPresent(productId);
123.         if (null != product) {
124.             return product;
125.         }
126.         //  2. 尝试从Redis中读取
127.         String key = PRODUCT_CACHE_PREFIX + productId;
128.         String value = stringRedisTemplate.opsForValue().get(key);
129.         if (StringUtils.isNotBlank(value)) {
130.             product = JSON.parseObject(value, Product.class);
131.             return product;
132.         }
133.         return null;
134.     }
136.     /**
137.      * 为了避免缓存集体失效，故而加了随机时间
138.      */
139.     private int getProductTimeout(int initVal) {
140.         Random random = new Random(10);
141.         return initVal + random.nextInt();
142.     }
143. }</long,>

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！