缓存一致性设计思路

目录

1. Spring注解使用，控制Redis缓存更新
2. 缓存一致性问题是如何产生的？
3. 双更新模式：操作不合理，导致数据一致性问题
4. “后删缓存”，能解决多数不一致
5. 大厂高并发，“后删缓存”依旧不一致
6. 如何解决高并发的不一致问题？延迟双删与闪电缓存
7. 如何解决缓存击穿？读操作互斥与集中更新

Redis 是现在互联网中使用最广泛的分布式缓存系统，几乎每家公司都在用。它的 qps 可以达到10万每秒，吞吐量还是非常可观的，对于一般体量的互联网公司，一台机器就够了。但不论是什么业务，都不得不面对一个棘手的问题：那就是Redis和源数据的一致性问题。

一、Spring注解使用，控制Redis缓存更新

使用 SpringBoot 可以很容易地对 Redis 进行操作。Java 的 Redis 的客户端常用的有三个：jedis、redisson、lettuce。其中，Spring 默认使用的是 lettuce。
很多人喜欢使用 Spring 抽象的缓存包 spring-cache，它可以使用注解，非常方便。它的注解采用 AOP 的方式，对 Cache 层进行了抽象，可以在各种堆内缓存框架和分布式框架之间进行切换。

我们来看一下它的 maven 坐标：

<dependency> 
    <groupId>org.springframework.boot</groupId> 
    <artifactId>spring-boot-starter-cache</artifactId> 
</dependency>

使用spring-cache有三个步骤：

1. 在启动类上加上@EnableCaching 注解；
2. 使用 CacheManager 初始化要使用的缓存框架，使用 @CacheConfig 注解注入要使用的资源；
3. 使用@Cacheable等注解对资源进行缓存。而针对缓存操作的注解有三个：

@Cacheable 表示如果缓存系统里没有这个数值，就将方法的返回值缓存起来；
@CachePut 表示每次执行该方法，都把返回值缓存起来；
@CacheEvict 表示执行方法的时候，清除某些缓存值。

二、缓存一致性问题是如何产生的？

在说缓存一致性问题如何产生的前，我们先看下缓存的API操作，缓存操作和数据库的CRUD结合起来，大致可以抽象成以下几个方法：

• getFromDB(key)
• getFromRedis(key)
• putToDB(key,value)
• putToRedis(key,value)
• deleteFromDB(key)
• deleteFromRedis(key)

把Redis当缓存使用，就说明Redis是不合适作为落地存储的。
一般我们是把最终的数据存放在数据库中的，，一般情况下，Redis 的操作速度比数据库的操作速度快得多。毕竟是 10wQPS 和上千 QPS 的对比。

上面这些 API 很简单，但把它们的顺序调整一下，一致性就会出现问题。一致性，简单说就是“数据库里的数据”与“Redis 中的数据”不一样了。
对于读的过程，一般是没什么异议的。

• 首先，读缓存；
• 如果缓存没有值，那就读取数据库的值；
• 同时把这个值写进缓存中；

我们下面主要看一下写模式。

三、双更新模式：操作不合理，导致数据一致性问题

我们来看下常见的一个错误编码方式，这些是代码 review 时要着重看的点，也是常出问题的地方。

public void putValue(key,value){
    putToRedis(key,value);
    putToDB(key,value);//操作失败了
}

比如我们需要更新一个值，首先刷了缓存，然后把数据库也更新了。但更新数据库过程中出现了异常，发生了回滚。所以，最后“缓存里的数据”和“数据库的数据”就不一样了，也就是出现了数据不一致的问题。

那如果先更新数据库，再更新缓存呢？如代码：

public void putValue(key,value){
    putToDB(key,value);
    putToRedis(key,value);
}

这依然会有问题。

考虑到下面的场景：操作 A 更新 a 的值为 1，操作 B 更新 a 的值为 2。由于数据库和 Redis 的操作，并不是原子的，它们的执行时长也不是可控制的。当两个请求的时序发生了错乱，就会发生缓存不一致的情况。

放到实操中来说：A 操作在更新数据库成功后，再更新 Redis；但在更新 Redis 之前，另外一个更新操作 B 执行完毕。那么操作 A 的这个 Redis 更新动作，就和数据库里面的值不一样了。
其实双更新模式的问题，主要不是体现在并发的一致性上，而是业务操作的合理性上。

我们大多数业务代码并没有经过良好的设计。一个缓存的值，可能是多条数据库记录拼凑或计算得出来的。比如一个余额操作，可能是“钱包里的值”加上“基金里的值”计算得出来的。

要是采用“更新”的方式，那这个计算代码就分散在项目的多个地方，这就不合理了。

那么怎么办呢？其实，我们把“缓存更新”改成“删除”就好了。

四、“后删缓存”，能解决多数不一致

因为每次读取时，如果判断 Redis 里没有值，就会重新读取数据库，这个逻辑是没问题的。唯一的问题是：我们是先删除缓存？还是后删除缓存？

答案是后者！

1、如果先删缓存

我们来看一下先删除缓存会有什么问题：

public void putValue(key,value){
    deleteFromRedis(key);
    putToDB(key,value);
}

操作 B 删除了某个 key 的值，这时候有另外一个请求 A 到来，那么它就会击穿到数据库，读取到旧的值。无论操作 B 更新数据库的操作持续多长时间，都会产生不一致的情况。

2、如果后删缓存

而把删除的动作放在后面，就能够保证每次读到的值都是新鲜的，从数据库里面拿到最新的。

public void putValue(key,value){
    putToDB(key,value);
    deleteFromRedis(key);
}

这就是我们通常说的Cache-Aside Pattern，也是我们平常使用最多的模式。我们看一下它的具体方式。
先看一下数据的读取过程，规则是“先读 cache，再读 db”，详细步骤如下：

1. 每次读取数据，都从 cache 里读；
2. 如果读到了，则直接返回，称作 cache hit；
3. 如果读不到 cache 的数据，则从 db 里面捞一份，称作 cache miss；
4. 将读取到的数据塞入到缓存中，下次读取时，就可以直接命中。

再来看一下写请求，规则是“先更新 db，再删除缓存”，详细步骤如下：

1. 将变更写入到数据库中；
2. 删除缓存里对应的数据。

为什么说最常用呢？因为 Spring cache 就是默认实现了这个模式。

五、大厂高并发，“后删缓存”依旧不一致

所以在高并发情况下，Cache Aside Pattern会不够用。下面就描述一个“先更新再删除”这种场景下，依然会产生不一致的情况。场景很好理解、很极端，但在高并发多实例的情况下很常见。

有一系列的高并发操作，一直执行着更新、删除的动作。某个时刻，它更新数据库的值为 1，然后删除了缓存。

public void proccess(key,value){
    N:putToDB(key,1);
    N:deleteFromRedis(key);

    A:getFromRedis(key);
    A:getFromDB(key)=1;
    B:putToDB(key,2);
    B:deleteFromRedis(key);
    A:putToRedis(key,1);

    //DB=2,Redis=1
}

正在这时，有两个请求发生了：

• 一个是读操作，读到的当然是数据库的旧值 1，我们记作操作 A；

• 同时，另外一个请求发起了更新操作，把数据库记录更新为 2，我们记作操作 B。

一般情况下，读取操作都是比写入操作快的，但我们要考虑两种极端情况：

• 一种是这个读取操作 A，发生在更新操作 B 的尾部；

• 一种是操作 A 的这个 Redis 的操作时长，耗费了非常多的时间。比如，这个节点正好发生了 STW。
  那么很容易地，读操作 A 的结束时间就超过了操作 B 删除的动作。就像上图虚线部分画的一样，这个时候，数据也是不一致的。

实际上，你也无法控制它们的执行顺序。只要发生这种情况，大概率数据库和 Redis 的值会不一致。

但为什么一般公司不去处理这种情况呢？你仔细看这张图，它发生的条件是非常苛刻的。它要求在一系列“并发写”的同时，还有“并发读”的参与。而一般业务是达不到这个量级的，所以一般公司不去处理这种情况，但高并发业务就非常常见了。

六、如何解决高并发的不一致问题？

大家看上面这种不一致情况发生的场景，归根结底还是“删除操作”发生在“更新操作”之前了。

1、延时双删

而假如有一种机制，能够确保删除动作一定被执行，那就可以解决问题，起码能缩小数据不一致的时间窗口。常用的方法就是延时双删，依然是先更新再删除，唯一不同的是：我们把这个删除动作，在不久之后再执行一次，比如 5 秒之后。

public void putValue(key,value){
    putToDB(key,value);
    deleteFromRedis(key);

    ...deleteFromRedis(key,after5sec);
}

而删除动作也有多种选择：

• 如果放在 DelayQueue 中，会有随着 JVM 进程的死亡，丢失更新的风险；

• 如果放在 MQ 中，会增加编码的复杂性。
  所以到了这个时候，并没有一个能够行走天下的解决方案。我们得综合评价很多因素去做设计，比如团队的水平、工期、不一致的忍受程度等。

2、闪电缓存

还有一种不太常用的，那就是采用闪电缓存。就是把缓存的失效时间设置非常短，比如 3～4 秒。一旦失效，就会再次去数据库读取最新数据到缓存。但这种方式，在非常高的并发下，同一时间对某个 key 的请求击穿到 DB，会锁死数据库，所以很少用。

对于一般并发场景，上面的各种修修补补，已经把不一致问题降低到很小的概率了。但是它仍然是有问题的，因为它引入了一个高可用问题：缓存击穿。

七、如何解决缓存击穿？

缓存击穿，指的是缓存中没有数据但数据库中有，由于同一时刻请求量特别大，但是没有读到缓存数据，就会一股脑涌入到数据库中读取，造成数据库假死。

任何删除缓存的动作都会造成缓存击穿。
所以我们上面一直说的是要删除缓存，但在极高并发下，你还不能乱删。
你反过头去看一下，好像我们一开始双更的方案比 Cache-Aside Pattern 还要靠谱一些，起码能用。怎么回事？代码还能不能写了？这就是业务开发中的特事特办，要专门针对这种功能进行编码。场景特殊时，代码也就不要追求极端优雅性了，毕竟也没有万能的解决方案。

这时，盘点一下我们手头上的工具，可以看到有两种不同的解决方式：

• 读操作互斥，使用锁或者分布式锁来控制；

• 更新集中，采用定时或者 binlog 的方式同步更新。

1、读操作互斥

先来看一下锁操作。我们依然采用 Cache-Aside Pattern，只不过在读的时候进行一下处理。来看一下伪代码，从 Redis 读取不到值的时候，我们要上锁去从数据库中读这个值。我们这里默认这个值是有的，否则就得处理缓存穿透的问题。

get(key){
    res = getFromRedis(key);
    //读取缓存为null
    if(null == res){
        lock.lock(...);
        //再次读取缓存为null
        res = getFromRedis(key);
        if(res == null){
            res = getFromDB(key);
            if(null != res){
                //读取设值
                putToRedis(key,res);
            }
        }
        lock.unlock();
    }
    return res;
}
getFromDB(key){
    ...
}

使用分布式锁和非分布式锁的主要区别，还是在于数据一致性窗口上：

• 对于多线程锁来说，可能某些节点执行得非常慢，更新了旧的值到 Redis；

• 对于分布式锁来说，肯定又是一个效率上的话题。

2、集中更新

我们再来看一下集中更新。这个很美好，但大多数业务很复杂，这对业务架构的前期设计要求非常高。比如通过 Binlog 方式，典型的如 Canal。我们不会在代码里做任何 Redis 更新的操作，而是会设计一个服务，订阅最新的 binlog 更新信息，然后解析它们，主动去更新缓存。这个一般在大并发大厂才会采用。

还有一种就是弱化数据库。所有的数据首先在 Redis 落地，也就是把 Redis 作为数据库使用，把数据库作为备份库使用。有定时任务，定期把 Redis 中的数据，保存到数据库或其他地方。

一般，重要业务还要配备一个对账系统，定时去扫描，以便快速发现不一致的情况。