击穿，穿透，雪崩

缓存击穿（Cache Breakdown）

定义

缓存击穿是指某个热点数据在缓存中失效，而有大量并发请求同时到达这个数据时，由于缓存失效，这些请求直接访问数据库，导致数据库瞬时压力激增，可能造成系统崩溃。

解决方案

1. 设置热点数据不过期：对于一些非常热点的数据，可以考虑设置永不过期，人工控制失效。
2. 使用互斥锁：在缓存失效时，通过加锁控制只有一个请求可以去加载数据和更新缓存，其他请求等待。例如，可以使用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）

定义

缓存穿透是指请求的数据既不在缓存中，也不存在于数据库中。每次请求都会去数据库查询，找不到数据后也不会写入缓存，这样恶意的攻击可能会使数据库遭受巨大的压力。

解决方案

1. 缓存空值：对于查询结果为空的数据，也缓存一个空结果，但需要设置较短的过期时间，以防止缓存污染。

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;
    }
}

1. 布隆过滤器：在缓存和数据库之前增加一个布隆过滤器，用于快速判断某个请求的数据是否存在。如果布隆过滤器认为数据不存在，则直接返回不存在，避免对数据库的查询。

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）

定义

缓存雪崩是指大量缓存数据在同一时间过期，导致大量请求同时到达数据库，可能引起数据库瞬时压力过大而崩溃。

解决方案

1. 缓存过期时间分散：在设置缓存数据的过期时间时，加上一个随机值，使缓存过期时间分散，避免集中过期。

   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);
       }
   }
   

2. 双缓存机制：设置主缓存和备用缓存。当主缓存失效时，使用备用缓存，从而减缓对数据库的压力。

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";
    }
}

1. 请求削峰：通过队列或者其他手段对瞬时大量请求进行削峰处理。

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();
    }
}

结论

缓存击穿、缓存穿透和缓存雪崩是缓存系统中需要解决的重要问题。通过合理的缓存设计和策略，如设置互斥锁、使用布隆过滤器、分散缓存过期时间、缓存空值和请求削峰，可以有效避免这些问题，保障系统的高可用性和稳定性。在实际应用中，需要根据具体场景和需求选择合适的解决方案，确保缓存系统的高效运行。