短信登陆
查询缓存
在程序运行时，查询数据库或调用外部接口是获取数据的常见操作，但这类操作往往受限于 IO 性能、网络状况或外部接口自身延迟，容易成为程序运行的性能瓶颈，导致整体响应变慢。
为解决这一问题，缓存机制应运而生：将频繁访问的数据存储在缓存中（缓存通常基于内存实现，具备极高的访问速度）。具体而言，首次查询数据时，从数据库或外部接口获取后，同步将数据存入缓存；后续再需查询相同数据时，则优先从缓存中读取，以此大幅提升数据访问效率，优化程序整体性能。
缓存模型与思路
标准的操作方式就是：先查询缓存，若缓存存在，则返回客户端；若缓存没有再查询数据库，然后将结果写入到客户端。
查询商铺如下：
public Result queryById(Long id) {
String key = "cache:shop:" + id;
String shopJson = stringRedisTemplate.opsForValue().get(key);
if (StrUtil.isNotEmpty(shopJson)) {
Shop shop = JSONUtil.toBean(shopJson, Shop.class);
return Result.ok(shop);
}
Shop shop = this.getById(id);
if (shop == null) {
return Result.fail("店铺不存在");
}
stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(shop), 30, TimeUnit.MINUTES);
return Result.ok(shop);
}
缓存更新策略
- 内存淘汰：当缓存数据达到了设定的max-memory时，会自动触发淘汰机制，淘汰掉不重要的数据（可以自行设置淘汰机制）
- 超时剔除：给redis设置过期时间ttl后，redis会将超时的数据定时删除
- 主动更新：人为主动的去更新或删除redis中的缓存数据
业务场景：
低一致性需求：使用内存淘汰机制
高一致性需求：主动更新，并以超时剔除作为兜底方案，
数据一致性
因为缓存的数据来自数据库或外部接口，当源头数据更新，而缓存数据未更新，就会带来缓存不一致的问题。
解决方案：缓存的调用者，在更新数据库的时候，同步更新缓存。
更新缓存有两种方式
- 删除缓存：每次操作完成数据库后，将缓存的数据删除，待别的线程下次查询数据时，将数据再放到缓存中
- 更新缓存：每次操作完成数据库后，同步将缓存的数据进行更新
两种方式：若在使用更新缓存的方式，当在更新缓存后，并没有线程来查询数据，那么缓存中的数据则无效，一定程度上浪费了空间。
如何保证缓存与数据库的操作同时成功或失效？
- 单体系统：可以将缓存操作与数据库操作放在同一事务中
- 分布式系统：利用TCC等分布式事务方案
删除缓存是先操作数据库还是先操作缓存？
如果先删除缓存，再操作数据库：
线程1先删除缓存 ——＞ 线程２查询缓存未命中，查询数据库，再将结果放入缓存 ——＞线程１更新数据库。这样会造成数据库更新后，缓存仍然是旧数据，一致等到缓存的数据失效后才能达到缓存一致性
缓存穿透
缓存穿透是指缓存和数据库都不存在数据，这样每次查询都会打到数据库。
解决方案：
- 缓存空对象：
优点：实现简单
缺点：空间浪费
- 布隆过滤：
优点：占用空间较少，没有多余key
缺点：实现复杂，可能存在误判
布隆过滤思想：
使用哈希的思想，先构建一个庞大的二进制数组，走哈希思想去判断当前要查询的数是否存在，若不存在，则返回；反之若存在，则继续向下执行查询动作。
缓存雪崩
缓存雪崩是指同一时间大量的缓存key同时失效或者Redis宕机，导致大量请求到达数据库，带来巨大压力。
解决方案：
-
给不同的Key的TTL添加随机值
-
利用Redis集群提高服务的可用性
-
给缓存业务添加降级限流策略
-
给业务添加多级缓存
缓存击穿
缓存击穿问题也称为热点key问题，是指一个高并发且缓存重建业务较复杂的key突然失效了，无数的请求会在瞬间给数据库带来巨大的冲击。
常见解决方案：
- 互斥锁
- 逻辑过期
- 解决方案一、使用锁来解决：
因为锁能实现互斥性。假设线程过来，只能一个人一个人的来访问数据库，从而避免对于数据库访问压力过大，但这也会影响查询的性能，因为此时会让查询的性能从并行变成了串行，我们可以采用tryLock方法 + double check来解决这样的问题。
假设现在线程1过来访问，他查询缓存没有命中，但是此时他获得到了锁的资源，那么线程1就会一个人去执行逻辑，假设现在线程2过来，线程2在执行过程中，并没有获得到锁，那么线程2就可以进行到休眠，直到线程1把锁释放后，线程2获得到锁，然后再来执行逻辑，此时就能够从缓存中拿到数据了。
- 解决方案二、逻辑过期方案
方案分析：我们之所以会出现这个缓存击穿问题，主要原因是在于我们对key设置了过期时间，假设我们不设置过期时间，其实就不会有缓存击穿的问题，但是不设置过期时间，这样数据不就一直占用我们内存了吗，我们可以采用逻辑过期方案。
我们把过期时间设置在 redis的value中，注意：这个过期时间并不会直接作用于redis，而是我们后续通过逻辑去处理。假设线程1去查询缓存，然后从value中判断出来当前的数据已经过期了，此时线程1去获得互斥锁，那么其他线程会进行阻塞，获得了锁的线程他会开启一个 线程去进行 以前的重构数据的逻辑，直到新开的线程完成这个逻辑后，才释放锁， 而线程1直接进行返回，假设现在线程3过来访问，由于线程线程2持有着锁，所以线程3无法获得锁，线程3也直接返回数据，只有等到新开的线程2把重建数据构建完后，其他线程才能走返回正确的数据。
这种方案巧妙在于，异步的构建缓存，缺点在于在构建完缓存之前，返回的都是脏数据。
互斥锁方案：由于保证了互斥性，所以数据一致，且实现简单，因为仅仅只需要加一把锁而已，也没其他的事情需要操心，所以没有额外的内存消耗，缺点在于有锁就有死锁问题的发生，且只能串行执行性能肯定受到影响
逻辑过期方案：线程读取过程中不需要等待，性能好，有一个额外的线程持有锁去进行重构数据，但是在重构数据完成前，其他的线程只能返回之前的数据，且实现起来麻烦
利用互斥锁解决缓存击穿问题
思路：进行查询之后，如果在缓存中没有查询到数据，则进行互斥锁的获取：
若能获取到锁，则进行查询数据，将查询的数据缓存到redis中，再释放锁；
若没能获取到锁，则休眠，过一段时间再尝试，直到获取到为止；
这样利用互斥锁，可以保证只有一个线程访问到数据库。
操作锁的代码：
利用redis的setnx方法来表示获取锁，该方法含义是redis中如果没有这个key，则插入成功，返回1，在stringRedisTemplate中返回true， 如果有这个key则插入失败，则返回0，在stringRedisTemplate返回false，我们可以通过true，或者是false，来表示是否有线程成功插入key，成功插入的key的线程我们认为他就是获得到锁的线程。
private boolean tryLock(String lockKey) {
boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(lockKey, "1", 10, TimeUnit.SECONDS);
return BooleanUtil.isTrue(flag);
}
private void unlock(String lockKey) {
stringRedisTemplate.delete(lockKey);
}
操作代码：
@Override
public Result queryById(Long id) {
Shop shop = queryWithMutex(id);
if (shop == null) {
return Result.fail("店铺不存在");
}
return Result.ok(shop);
}
private Shop queryWithMutex(Long id) {
String key = RedisConstants.CACHE_SHOP_KEY + id;
String shopJson = stringRedisTemplate.opsForValue().get(key);
if (StrUtil.isNotEmpty(shopJson)) {
Shop shop = JSONUtil.toBean(shopJson, Shop.class);
return shop;
}
// 判断命中的值是否为空值
if (shopJson != null) {
return null;
}
String lockKey = RedisConstants.LOCK_SHOP_KEY + id;
Shop shop = null;
try {
boolean lockFlag = tryLock(lockKey);
if (!lockFlag) {
TimeUnit.SECONDS.sleep(1);
return queryWithMutex(id);
}
shop = this.getById(id);
if (shop == null) {
stringRedisTemplate.opsForValue().set(key, "", RedisConstants.CACHE_NULL_TTL, TimeUnit.MINUTES);
return null;
}
stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(shop), 30, TimeUnit.MINUTES);
return shop;
} catch (Exception e) {
log.error("queryId err", e);
throw new RuntimeException(e);
} finally {
unlock(lockKey);
}
}
利用逻辑过期解决缓存击穿问题
需求：修改根据id查询商铺的业务，基于逻辑过期方式来解决缓存击穿问题
思路分析：当用户开始查询redis时，判断是否命中，如果没有命中则直接返回空数据，不查询数据库，而一旦命中后，将value取出，判断value中的过期时间是否满足，如果没有过期，则直接返回redis中的数据，如果过期，则在开启独立线程后直接返回之前的数据，独立线程去重构数据，重构完成后释放互斥锁。
封装Redis工具类
package com.hmdp.utils;
import cn.hutool.core.util.BooleanUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.json.JSONObject;
import cn.hutool.json.JSONUtil;
import com.fasterxml.jackson.core.ObjectCodec;
import lombok.extern.slf4j.Slf4j;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;
import java.time.LocalDateTime;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.function.Function;
import static com.hmdp.utils.RedisConstants.CACHE_NULL_TTL;
import static com.hmdp.utils.RedisConstants.LOCK_SHOP_KEY;
@Slf4j
@Component
public class CacheClient {
private StringRedisTemplate stringRedisTemplate;
private static final ExecutorService CACHE_REBUILD_EXECUTOR = Executors.newFixedThreadPool(10);
public CacheClient(StringRedisTemplate stringRedisTemplate) {
this.stringRedisTemplate = stringRedisTemplate;
}
public void set(String key, Object value, long time, TimeUnit timeUnit) {
stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(value), time, timeUnit);
}
public void setWithLogicalExpire(String key, Object value, long time, TimeUnit timeUnit) {
// 设置数据
RedisData redisData = new RedisData();
redisData.setData(value);
redisData.setExpireTime(LocalDateTime.now().plusSeconds(timeUnit.toSeconds(time)));
// 放入redis中
stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(redisData));
}
public <R, ID> R queryWithPassThrough(String keyPrefix, ID id, Class<R> type, Function<ID, R> dbFallback, long time, TimeUnit timeUnit) {
String key = keyPrefix + id;
String json = stringRedisTemplate.opsForValue().get(key);
if (StrUtil.isNotBlank(json)) {
return JSONUtil.toBean(json, type);
}
if (json != null) {
return null;
}
R value = dbFallback.apply(id);
if (value == null) {
stringRedisTemplate.opsForValue().set(key, "", CACHE_NULL_TTL, TimeUnit.SECONDS);
return null;
}
this.set(key, value, time, timeUnit);
return value;
}
public <R, Id> R queryWithLogicalExpire(String keyPrefix, Id id, Class<R> type, Function<Id, R> dbFallback, long time, TimeUnit timeUnit) {
String key = keyPrefix + id;
String json = stringRedisTemplate.opsForValue().get(key);
if (StrUtil.isEmpty(json)) {
return null;
}
RedisData redisData = JSONUtil.toBean(json, RedisData.class);
R value = JSONUtil.toBean((JSONObject) redisData.getData(), type);
LocalDateTime expireTime = redisData.getExpireTime();
if (expireTime.isAfter(LocalDateTime.now())) {
return value;
}
String lockKey = LOCK_SHOP_KEY + id;
boolean lockFlag = tryLock(lockKey);
if (lockFlag) {
// 6.3.成功，开启独立线程，实现缓存重建
CACHE_REBUILD_EXECUTOR.submit(() -> {
try {
// 查询数据库
log.info("异步查询店铺");
R newR = dbFallback.apply(id);
// 重建缓存
this.setWithLogicalExpire(key, newR, time, timeUnit);
} catch (Exception e) {
throw new RuntimeException(e);
} finally {
// 释放锁
unlock(lockKey);
}
});
}
// 6.4.返回过期的商铺信息
return value;
}
public <R, ID> R queryWithMutex(String keyPrefix, ID id, Class<R> type, Function<ID, R> dbFallback, long time, TimeUnit timeUnit) {
String key = keyPrefix + id;
String json = stringRedisTemplate.opsForValue().get(key);
if (StrUtil.isNotBlank(json)) {
return JSONUtil.toBean(json, type);
}
if (json != null) {
return null;
}
String lockKey = LOCK_SHOP_KEY + id;
try {
boolean lockFlag = tryLock(lockKey);
if (!lockFlag) {
TimeUnit.SECONDS.sleep(1);
return queryWithMutex(keyPrefix, id, type, dbFallback, time, timeUnit);
}
R value = dbFallback.apply(id);
if (value == null) {
stringRedisTemplate.opsForValue().set(key, "", CACHE_NULL_TTL, TimeUnit.SECONDS);
return null;
}
this.set(key, value, time, timeUnit);
return value;
} catch (Exception e) {
throw new RuntimeException(e);
} finally {
unlock(lockKey);
}
}
private boolean tryLock(String key) {
Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(key, "1", 10, TimeUnit.SECONDS);
return BooleanUtil.isTrue(flag);
}
private void unlock(String key) {
stringRedisTemplate.delete(key);
}
}
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
