先做一个说明，从理论上来说，有两种处理思维，一种需保证数据强一致性，这样性能肯定大打折扣；另外我们可以采用最终一致性，保证性能的基础上，允许一定时间内的数据不一致，但最终数据是一致的。
1 强一致性思想
这种考虑方式就要用到分布式事务，比如2PC、tcc、Paxos协议等都可以保证一致性。
  我们还可以通过读请求和写请求串行化，串到一个内存队列里去。
  串行化可以保证一定不会出现不一致的情况，但是它也会导致系统的吞吐量大幅度降低，用比正常情况下多几倍的机器去支撑线上的一个请求。
2 最终一致性思想
从理论上来说，给缓存设置过期时间，是保证最终一致性的解决方案。这种方案下，我们可以对存入缓存的数据设置过期时间，所有的写操作以数据库为准，对缓存操作只是尽最大努力即可。也就是说如果数据库写成功，缓存更新失败，那么只要到达过期时间，则后面的读请求自然会从数据库中读取新值然后回填缓存。
  那么接下来，我们只需要讨论更新的策略了。
(1)先更新数据库，还是先更新缓存
先更新数据库
同时有请求A和请求B进行更新操作，那么会出现
  1-线程A更新了数据库
  2-线程B更新了数据库
  3-线程B更新了缓存
  4-线程A更新了缓存
  这就出现请求A更新缓存应该比请求B更新缓存早才对，但是因为网络等原因，B却比A更早更新了缓存。这就导致了脏数据，因此不考虑。
先更新缓存，再更新数据库，最大的问题就是可能会丢失数据。在软件设计上，我们基本上不可能做出一个没有缺陷的设计，就像算法设计中的时间换空间，空间换时间一个道理，有时候，强一致性和高性能，高可用和高性性是有冲突的。软件设计从来都是取舍Trade-Off。
   Write Back套路，一句说就是，在更新数据的时候，只更新缓存，不更新数据库，而我们的缓存会异步地批量更新数据库。这个设计的好处就是让数据的I/O操作飞快无比（因为直接操作内存嘛 ），因为异步，write backg还可以合并对同一个数据的多次操作，所以性能的提高是相当可观的。
不再更新缓存，直接删除，为什么？
业务角度考虑
原因很简单，很多时候，在复杂点的缓存场景，缓存不单单是数据库中直接取出来的值。比如可能更新了某个表的一个字段，然后其对应的缓存，是需要查询另外两个表的数据并进行运算，才能计算出缓存最新的值的。
另外更新缓存的代价有时候是很高的。是不是说，每次修改数据库的时候，都一定要将其对应的缓存更新一份？也许有的场景是这样，但是对于比较复杂的缓存数据计算的场景，就不是这样了。如果你频繁修改一个缓存涉及的多个表，缓存也频繁更新。但是问题在于，这个缓存到底会不会被频繁访问到？
举个栗子，一个缓存涉及的表的字段，在 1 分钟内就修改了 20 次，或者是 100 次，那么缓存更新 20 次、100 次；但是这个缓存在 1 分钟内只被读取了 1 次，有大量的冷数据。实际上，如果你只是删除缓存的话，那么在 1 分钟内，这个缓存不过就重新计算一次而已，开销大幅度降低。用到缓存才去算缓存。
设计角度考虑
其实删除缓存，而不是更新缓存，就是一个 lazy 计算的思想，不要每次都重新做复杂的计算，不管它会不会用到，而是让它到需要被使用的时候再重新计算。像 mybatis，hibernate，都有懒加载思想。查询一个部门，部门带了一个员工的 list，没有必要说每次查询部门，都里面的 1000 个员工的数据也同时查出来啊。80% 的情况，查这个部门，就只是要访问这个部门的信息就可以了。先查部门，同时要访问里面的员工，那么这个时候只有在你要访问里面的员工的时候，才会去数据库里面查询 1000 个员工。
(2)先删缓存，再更新数据库
问题一：线程顺序
该方案会导致不一致的原因是。同时有一个请求A进行更新操作，另一个请求B进行查询操作。那么会出现如下情形:
  1-请求A进行写操作，删除缓存
  2-请求B查询发现缓存不存在
  3-请求B去数据库查询得到旧值
  4-请求B将旧值写入缓存
  5-请求A将新值写入数据库
  上述情况就会导致不一致的情形出现。而且，如果不采用给缓存设置过期时间策略，该数据永远都是脏数据。
问题二：如果你用了mysql的读写分离架构怎么办？
在这种情况下，造成数据不一致的原因如下，还是两个请求，一个请求A进行更新操作，另一个请求B进行查询操作。
  1-请求A进行写操作，删除缓存
  2-请求A将数据写入数据库了，
  3-请求B查询缓存发现，缓存没有值
  4-请求B去从库查询，这时，还没有完成主从同步，因此查询到的是旧值
  5-请求B将旧值写入缓存
  6-数据库完成主从同步，从库变为新值
  上述情形，就是数据不一致的原因。
解决一：采用延时双删策略
伪代码如下
public void write(String key,Object data){
   redis.delKey(key);
   db.updateData(data);
   Thread.sleep(1000);
   redis.delKey(key);
123456
转化为中文描述就是
  1-先淘汰缓存
  2-再写数据库（这两步和原来一样）
  3-休眠1秒，再次淘汰缓存
  这么做，可以将1秒内所造成的缓存脏数据，再次删除。
那么，这个1秒怎么确定的，具体该休眠多久呢？
针对上面的情形，读者应该自行评估自己的项目的读数据业务逻辑的耗时。然后写数据的休眠时间则在读数据业务逻辑的耗时基础上，加几百ms即可。这么做的目的，就是确保读请求结束，写请求可以删除读请求造成的缓存脏数据。
采用这种同步淘汰策略，吞吐量降低怎么办？
解决二：异步
那就将第二次删除作为异步的。自己起一个线程，异步删除。这样，写的请求就不用沉睡一段时间后了，再返回。这么做，加大吞吐量。
  第二次删除,如果删除失败怎么办？
  这是个非常好的问题，因为第二次删除失败，就会出现如下情形。还是有两个请求，一个请求A进行更新操作，另一个请求B进行查询操作，为了方便，假设是单库：
（1）请求A进行写操作，删除缓存

（2）请求B查询发现缓存不存在

（3）请求B去数据库查询得到旧值

（4）请求B将旧值写入缓存

（5）请求A将新值写入数据库

（6）请求A试图去删除请求B写入对缓存值，结果失败了。

ok,这也就是说。如果第二次删除缓存失败，会再次出现缓存和数据库不一致的问题。

如何解决呢？我们继续往下看。
(3)先更新数据库，再删缓存
Cache-Aside pattern
首先，先说一下。老外提出了一个缓存更新套路，名为《Cache-Aside pattern》。其中就指出
  失效：应用程序先从cache取数据，没有得到，则从数据库中取数据，成功后，放到缓存中。
  命中：应用程序从cache中取数据，取到后返回。
  更新：先把数据存到数据库中，成功后，再让缓存失效。
另外，知名社交网站facebook也在论文《Scaling Memcache at Facebook》中提出，他们用的也是先更新数据库，再删缓存的策略。
这种情况不存在并发问题么？不是的。假设这会有两个请求，一个请求A做查询操作，一个请求B做更新操作，那么会有如下情形产生
  1-缓存刚好失效
  2-请求A查询数据库，得一个旧值
  3-请求B将新值写入数据库
  4-请求B删除缓存
  5-请求A将查到的旧值写入缓存
  如果发生上述情况，确实是会发生脏数据。
然而，发生这种情况的概率又有多少呢？
  发生上述情况有一个先天性条件，就是步骤（3）的写数据库操作比步骤（2）的读数据库操作耗时更短，才有可能使得步骤（4）先于步骤（5）。可是，大家想想，数据库的读操作的速度远快于写操作的（不然做读写分离干嘛，做读写分离的意义就是因为读操作比较快，耗资源少），因此步骤（3）耗时比步骤（2）更短，这一情形很难出现。
首先，给缓存设有效时间是一种方案。
  其次，采用异步延时删除策略，保证读请求完成以后，再进行删除操作。
还有其他造成不一致的原因么？
  有的，这也是缓存更新策略（2）和缓存更新策略（3）都存在的一个问题，如果删缓存失败了怎么办，那不是会有不一致的情况出现么。比如一个写数据请求，然后写入数据库了，删缓存失败了，这会就出现不一致的情况了。这也是缓存更新策略（2）里留下的最后一个疑问。
异步优化方式：消息队列
流程如下所示
  1-更新数据库数据；
  2-缓存因为种种问题删除失败
  3-将需要删除的key发送至消息队列
  4-自己消费消息，获得需要删除的key
  5-继续重试删除操作，直到成功
  然而，该方案有一个缺点，对业务线代码造成大量的侵入。
异步优化方式：基于订阅binlog的同步机制
流程如下图所示：

1-更新数据库数据
  2-数据库会将操作信息写入binlog日志当中
  3-订阅程序提取出所需要的数据以及key
  4-另起一段非业务代码，获得该信息
  5-尝试删除缓存操作，发现删除失败
  6-将这些信息发送至消息队列
  7-重新从消息队列中获得该数据，重试操作。
上述的订阅binlog程序在mysql中有现成的中间件叫canal，可以完成订阅binlog日志的功能。另外，重试机制，可以采用的是消息队列的方式。如果对一致性要求不是很高，也可以直接在程序中另起一个线程，每隔一段时间去重试即可。
如何保证缓存与数据库一致性

Java进阶面试必问：如何保证缓存与数据库的双写一致性？

数据库缓存最终一致性的四种方案，你真的了解过吗？

标题：缓存和数据库一致性问题

作者：jackssybin

地址：https://jackssybin.cn/articles/2020/11/04/1604469398210.html