基于single flight来解决缓存击穿

1. 缓存击穿

高并发场景下，某个缓存到了过期时间，自动失效，导致大量请求在该缓存中查询不到值，会直接请求数据库进行查询，连接过多可能会导致数据库压力过大无法响应，从而导致系统宕机。

2. 常见解决方案

缓存永不过期

既然缓存过期会导致缓存，我们可以让它没机会过期，在设置缓存过期时间时设置为永不过期就好了。

这种方式简单且方便理解，但缺点也明显。

首先缓存本身不是做永久性数据存储，要不然也不会叫做’缓’存，缓存一般使用的是内存，相对于磁盘来说是一种昂贵的资源，当需要缓存的数据很多时，永不过期的方式弊大于利。

从业务层面来说，很多时候缓存的数据都是热门数据，比如说活动页，大促商品，会吸引大量请求，需要缓存缓解数据库压力，如果活动结束，大促结束，这些数据的请求急剧降低，无需在缓存中存在，永不过期就不是理想的方案。

缓存一个空值

缓存失效时，可能是因为DB的数据已删除，为了保证一致性，缓存中的数据也会删除，此时如果大量查询进来，缓存中无数据，也会打到DB。

缓存一个空值对上述场景可减轻DB压力。

加分布式锁

要保证只有一个请求查询DB，显而易见的一个方案就是加锁，对于查询DB的函数，加上分布式锁来控制查询，当有请求获取到锁时，其他请求只能轮询等待。

这样当然也有很大弊端，需要不断的释放锁获取锁，对锁进行整个生命周期的管理。另外加锁也会对查询的并发带来很大的降低。

3.single flight方式

single flight设计思想，Go语言开发者应该都很熟悉，譬如go-zero框架中的， core/syncx/singleflight.go，

将并发请求合并成一个请求，以减少对下层服务的压力。

将single flight应用到缓存击穿场景上，基本思想就是：

确保在缓存失效后，只有一个线程去加载数据，其余线程等待该线程完成加载后直接使用其结果。

3.1 模拟业务场景

简单用业务代码模拟一个业务场景：

优先从缓存中查询数据，如果缓存不存在再查询DB，缓存设置一定的过期时间。

代码如下：

public class CacheExpired {private final static JedisPool jedisPool = new JedisPool("localhost", 6379);public static void main(String[] args) {//初始化缓存try (Jedis jedis = jedisPool.getResource()) {jedis.psetex("key", 300, "value");}CacheExpired cacheExpired = new CacheExpired();ExecutorService executorService = Executors.newFixedThreadPool(5);List<Future<String>> futures = new ArrayList<>();for (int i = 0; i < 10; i++) {Future<String> result = executorService.submit(() -> {//先从缓存中获取String s = cacheExpired.loadFromCache();if (s != null) {return s;}//缓存中无数据时，再从DB中获取。s = cacheExpired.loadFromDB();return s;});futures.add(result);}for (Future<String> future : futures) {try {System.out.println(future.get());} catch (InterruptedException | ExecutionException e) {throw new RuntimeException(e);}}}public String loadFromDB() {try {//从db获取数据是个耗时的操作Thread.sleep(1000);} catch (InterruptedException e) {throw new RuntimeException(e);}//更新缓存try (Jedis jedis = jedisPool.getResource()) {jedis.psetex("key", 200, "value");}return Thread.currentThread().getName() + "：从db获取数据成功";}public String loadFromCache() {try (Jedis jedis = jedisPool.getResource()) {//模拟从缓存中获取数据Thread.sleep(100);String cachedValue = jedis.get("key");if (cachedValue != null) {return Thread.currentThread().getName() + "：从缓存获取数据成功";}} catch (InterruptedException e) {throw new RuntimeException(e);}System.out.println(Thread.currentThread().getName() + "：缓存中无数据");return null;}
}

当缓存失效时，如上，高并发场景下，DB将承担所有的查询请求，会给DB带来巨大的压力，造成缓存击穿。

3.2 使用single flight的方式

这里讨论使用single flight的方式主要就是为了替换掉加锁的逻辑，需要保证以下两点：

1.只会有一个请求查询DB

2.其他请求需要获取第一个请求查询DB后的数据

总结起来就是等待计算。

恰好JDK中包含有支持此逻辑的功能：Future。

Future表示异步计算的结果，Future提供了多个方法用来校验执行计算的结果是否完成，并且等待计算的完成，在计算完成之前，会一直阻塞等待。

对于上面要保证的两点，可以使用Map + Future的方式来实现。

Map用来缓存第一次请求，Key是请求参数，Value为Future包装的异步计算的结果。

后续的请求根据Key获取到第一次请求查询封装的Future，然后通过Future.get()，获取第一次查询DB的结果。

如下String singleFlight()中

请求进来时，判断Map中是否有相同的请求。
如果没有包装成FutureTask放入Map中。
执行FutureTask的run()方法。
如果其他请求此时进来，Map中已有相同请求在执行，其他请求会在Future.get()处阻塞等待第一次请求的结果。

为了更好的观测执行效果，我们可以将从redis中获取缓存的逻辑去掉，直接全部请求DB。

public class CacheExpired {//    private final static JedisPool jedisPool = new JedisPool("localhost", 6379);public static void main(String[] args) {//        //初始化缓存//        try (Jedis jedis = jedisPool.getResource()) {//            jedis.psetex("key", 300, "value");//        }CacheExpired cacheExpired = new CacheExpired();ExecutorService executorService = Executors.newFixedThreadPool(5);List<Future<String>> futures = new ArrayList<>();for (int i = 0; i < 10; i++) {Future<String> result = executorService.submit(() -> {//                //先从缓存中获取//                String s = cacheExpired.loadFromCache();//                if (s != null) {//                    return s;//                }//全部从DB中获取。String s = cacheExpired.singleFlight();return s;});futures.add(result);}for (Future<String> future : futures) {try {System.out.println(future.get());} catch (InterruptedException | ExecutionException e) {throw new RuntimeException(e);}}}//存储正在进行或者已完成的请求，如果多个请求同时进来，可保证只有一个请求回去查询DBprivate final ConcurrentHashMap<String, Future<String>> cache = new ConcurrentHashMap<>();public String singleFlight() throws Exception {while (true) {Future<String> future = cache.get("key");if (future == null) {Callable<String> callable = () -> {loadFromDB();return "执行完成";};FutureTask<String> futureTask = new FutureTask<>(callable);future = cache.putIfAbsent("key", futureTask);if (future == null) {future = futureTask;futureTask.run(); // 执行加载任务}}try {return future.get(); // 等待结果} catch (CancellationException e) {cache.remove("key", future);System.out.println(e);} catch (ExecutionException e) {throw new Exception(e.getCause());}}}public void loadFromDB() {try {//从db获取数据是个耗时的操作Thread.sleep(1000);} catch (InterruptedException e) {throw new RuntimeException(e);}System.out.println(Thread.currentThread().getName() + "：从db获取数据成功");}
}