基于single flight来解决缓存击穿

走了一些弯路

已于 2024-06-17 17:47:09 修改

阅读量774

点赞数 19

分类专栏：架构设计文章标签：缓存 future 并发编程 JUC 缓存穿透 Map

于 2024-06-17 17:11:22 首次发布

本文链接：https://blog.csdn.net/zhanghailang1/article/details/139749292

版权

架构设计专栏收录该内容

6 篇文章 0 订阅

订阅专栏

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

    //存储正在进行或者已完成的请求，如果多个请求同时进来，可保证只有一个请求回去查询DB
    private 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获取数据成功");
    }
}