缓存击穿(Cache Breakdown)
定义
缓存击穿是指某个热点数据在缓存中失效,而有大量并发请求同时到达这个数据时,由于缓存失效,这些请求直接访问数据库,导致数据库瞬时压力激增,可能造成系统崩溃。
解决方案
- 设置热点数据不过期:对于一些非常热点的数据,可以考虑设置永不过期,人工控制失效。
- 使用互斥锁:在缓存失效时,通过加锁控制只有一个请求可以去加载数据和更新缓存,其他请求等待。例如,可以使用Redis的分布式锁实现:
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import redis.clients.jedis.Jedis;
public class CacheBreakdown {
private static Jedis jedis = new Jedis("localhost");
private static Lock lock = new ReentrantLock();
public static String getData(String key) {
String data = jedis.get(key);
if (data == null) {
if (lock.tryLock()) {
try {
data = fetchFromDB(key); // 从数据库获取数据
jedis.setex(key, 60, data); // 更新缓存,过期时间为60秒
} finally {
lock.unlock();
}
} else {
try {
Thread.sleep(100); // 等待一段时间后重试
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
return getData(key);
}
}
return data;
}
private static String fetchFromDB(String key) {
// 模拟从数据库获取数据
return "data_from_db";
}
}
缓存穿透(Cache Penetration)
定义
缓存穿透是指请求的数据既不在缓存中,也不存在于数据库中。每次请求都会去数据库查询,找不到数据后也不会写入缓存,这样恶意的攻击可能会使数据库遭受巨大的压力。
解决方案
- 缓存空值:对于查询结果为空的数据,也缓存一个空结果,但需要设置较短的过期时间,以防止缓存污染。
public class CachePenetration {
private static Jedis jedis = new Jedis("localhost");
public static String getData(String key) {
String data = jedis.get(key);
if (data == null) {
data = fetchFromDB(key);
if (data == null) {
jedis.setex(key, 60, ""); // 缓存空值,过期时间为60秒
} else {
jedis.setex(key, 300, data); // 缓存实际数据,过期时间为300秒
}
} else if ("".equals(data)) {
return null;
}
return data;
}
private static String fetchFromDB(String key) {
// 模拟从数据库获取数据
return null;
}
}
- 布隆过滤器:在缓存和数据库之前增加一个布隆过滤器,用于快速判断某个请求的数据是否存在。如果布隆过滤器认为数据不存在,则直接返回不存在,避免对数据库的查询。
import com.google.common.hash.BloomFilter;
import com.google.common.hash.Funnels;
import redis.clients.jedis.Jedis;
public class CachePenetrationWithBloomFilter {
private static Jedis jedis = new Jedis("localhost");
private static BloomFilter<String> bloomFilter = BloomFilter.create(Funnels.stringFunnel(), 100000, 0.001);
public static void addToBloom(String key) {
bloomFilter.put(key);
}
public static boolean isInBloom(String key) {
return bloomFilter.mightContain(key);
}
public static String getData(String key) {
if (!isInBloom(key)) {
return null;
}
String data = jedis.get(key);
if (data == null) {
data = fetchFromDB(key);
if (data == null) {
jedis.setex(key, 60, ""); // 缓存空值,过期时间为60秒
} else {
jedis.setex(key, 300, data); // 缓存实际数据,过期时间为300秒
}
} else if ("".equals(data)) {
return null;
}
return data;
}
private static String fetchFromDB(String key) {
// 模拟从数据库获取数据
return null;
}
}
缓存雪崩(Cache Avalanche)
定义
缓存雪崩是指大量缓存数据在同一时间过期,导致大量请求同时到达数据库,可能引起数据库瞬时压力过大而崩溃。
解决方案
- 缓存过期时间分散:在设置缓存数据的过期时间时,加上一个随机值,使缓存过期时间分散,避免集中过期。
import redis.clients.jedis.Jedis; import java.util.Random; public class CacheAvalanche { private static Jedis jedis = new Jedis("localhost"); private static Random random = new Random(); public static void setData(String key, String data) { int expireTime = 300 + random.nextInt(60); // 300秒基础上增加0-60秒的随机过期时间 jedis.setex(key, expireTime, data); } }
- 双缓存机制:设置主缓存和备用缓存。当主缓存失效时,使用备用缓存,从而减缓对数据库的压力。
public class DoubleCache {
private static Jedis jedis = new Jedis("localhost");
public static String getData(String key) {
String data = jedis.get("primary:" + key);
if (data == null) {
data = jedis.get("secondary:" + key);
if (data == null) {
data = fetchFromDB(key);
jedis.setex("primary:" + key, 300, data);
jedis.setex("secondary:" + key, 600, data);
} else {
jedis.setex("primary:" + key, 300, data);
}
}
return data;
}
private static String fetchFromDB(String key) {
// 模拟从数据库获取数据
return "data_from_db";
}
}
- 请求削峰:通过队列或者其他手段对瞬时大量请求进行削峰处理。
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import redis.clients.jedis.Jedis;
public class PeakShaving {
private static Jedis jedis = new Jedis("localhost");
private static BlockingQueue<String> requestQueue = new ArrayBlockingQueue<>(1000);
public static void startWorker() {
new Thread(() -> {
while (true) {
try {
String key = requestQueue.take();
String data = fetchFromDB(key);
jedis.setex(key, 300, data);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
}).start();
}
public static String getData(String key) {
String data = jedis.get(key);
if (data == null) {
try {
requestQueue.put(key);
return "Request is being processed";
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
return data;
}
private static String fetchFromDB(String key) {
// 模拟从数据库获取数据
return "data_from_db";
}
public static void main(String[] args) {
startWorker();
}
}
结论
缓存击穿、缓存穿透和缓存雪崩是缓存系统中需要解决的重要问题。通过合理的缓存设计和策略,如设置互斥锁、使用布隆过滤器、分散缓存过期时间、缓存空值和请求削峰,可以有效避免这些问题,保障系统的高可用性和稳定性。在实际应用中,需要根据具体场景和需求选择合适的解决方案,确保缓存系统的高效运行。