缓存由于其高并发和高性能的特性，已经在项目中被广泛使用，在读取缓存方面，大家没啥疑问，都是按照下图的流程来进行业务操作。

从理论上来说，给缓存设置过期时间，是保证最终一致性的解决方案。这种方案下，我们可以
对存入缓存的数据设置过期时间，所有的写操作以数据库为准，对缓存操作只是尽最大努力即可。也就是说如果数据库写成功，缓存更新失败，那么只要到达过期时间，则后面的读请求自然会从数据库中读取新值然后回填缓存。因此，接下来讨论的思路不依赖于给缓存设置过期时间这个方案。

在这里，我们讨论三种更新策略：

先更新数据库，再更新缓存
先删除缓存，再更新数据库
先更新数据库，再删除缓存

- 先更新数据库，再更新缓存

这套方案，大家是普遍反对的。为什么呢？有如下两点原因。

1.线程安全角度

同时有请求A和请求B进行更新操作，那么会出现

（1）线程A更新了数据库
（2）线程B更新了数据库
（3）线程B更新了缓存
（4）线程A更新了缓存

这就出现请求A更新缓存应该比请求B更新缓存早才对，但是因为网络等原因，B却比A更早更新了缓存。这就导致了脏数据，因此不考虑。

2.业务场景角度

有如下两点：

1. 如果你是一个写数据库场景比较多，而读数据场景比较少的业务需求，采用这种方案就会导致，数据压根还没读到，缓存就被频繁的更新，浪费性能。
2. 如果你写入数据库的值，并不是直接写入缓存的，而是要经过一系列复杂的计算再写入缓存。那么，每次写入数据库后，都再次计算写入缓存的值，无疑是浪费性能的。显然，删除缓存更为适合。

接下来讨论的就是争议最大的，先删缓存，再更新数据库。还是先更新数据库，再删缓存的问题。

对于一个不能保证事务性的操作，一定涉及“哪个任务先做，哪个任务后做”的问题，解决这个问题的方向是：

如果出现不一致，谁先做对业务的影响较小，就谁先执行

• 假设先写数据库，再淘汰缓存：
  第一步写数据库操作成功，第二步淘汰缓存失败，则会出现DB中是新数据，Cache中是旧数据，数据不一致。

• 假设先淘汰缓存，再写数据库：
  第一步淘汰缓存成功，第二步写数据库失败，则只会引发一次Cache miss。

结论：数据和缓存的操作时序，结论是清楚的：先淘汰缓存，再写数据库。

但是这真的正确么？
我们对此作出详细的分析

- 先删缓存，再更新数据库

该方案会导致不一致的原因是。同时有一个请求A进行更新操作，另一个请求B进行查询操作。那么会出现如下情形:

（1）请求A进行写操作，删除缓存
（2）请求B查询发现缓存不存在
（3）请求B去数据库查询得到旧值
（4）请求B将旧值写入缓存
（5）请求A将新值写入数据库

上述情况就会导致不一致的情形出现。而且，如果不采用给缓存设置过期时间策略，该数据永远都是脏数据。

那么，如何解决呢？采用延时双删策略
伪代码如下

public void write(String key,Object data){redis.delKey(key);db.updateData(data);Thread.sleep(1000);redis.delKey(key);}

转化为中文描述就是

（1）先淘汰缓存
（2）再写数据库（这两步和原来一样）
（3）休眠1秒，再次淘汰缓存

那么，这个1秒怎么确定的，具体该休眠多久呢？

针对上面的情形，读者应该自行评估自己的项目的读数据业务逻辑的耗时。以及主备复制的时间差，然后写数据的休眠时间则在读数据业务逻
辑的耗时基础上，加几百ms即可。这么做的目的，就是确保读请求结束，写请求可以删除读请求造成的缓存脏数据。

第二次删除,如果删除失败怎么办？

这里我们可以将 删除行为封装成 消息或者事件进行异步处理。这里就涉及到了可靠消息的问题了。

先更新数据库，再删缓存

第一步写数据库操作成功，第二步淘汰缓存失败，则会出现DB中是新数据，Cache中是旧数据，数据不一致

上文因为上述原因否定了这个方案

但是我们在先删除缓存再更新数据库的时候提到过两次删除的方案，同样会涉及到缓存删除失败的问题。这个问题我们是可以合理的去解决的

所以现在我们再来分析下这个方案

这种情况会存在并发问题么？
不是的。假设这会有两个请求，一个请求A做查询操作，一个请求B做更新操作，那么会有如下情形产生

（1）缓存刚好失效
（2）请求A查询数据库，得一个旧值
（3）请求B将新值写入数据库
（4）请求B删除缓存
（5）请求A将查到的旧值写入缓存
ok，如果发生上述情况，确实是会发生脏数据。

发生上述情况有一个先天性条件，

就是步骤（3）的写数据库操作比步骤（2）的读数据库操作耗时更短，才有可能使得步骤（4）先于步骤（5）。可是，大家想想，数据库的读操作的速度远快于写操作的（不然做读写分离干嘛，做读写分离的意义就是因为读操作比较快，耗资源少），因此步骤（3）耗时比步骤（2）更短，这一情形很难出现。

假设，有人非要抬杠，有强迫症，一定要解决怎么办？
如何解决上述并发问题？
首先，给缓存设有效时间是一种方案。其次，采用策略（2）里给出的异步延时删除策略，保证读请求完成以后，再进行删除操作。

缓存删除重试方案

（1）更新数据库数据；
（2）缓存因为种种问题删除失败
（3）将需要删除的key发送至消息队列
（4）自己消费消息，获得需要删除的key
（5）继续重试删除操作，直到成功

然而，该方案有一个缺点，对业务线代码造成大量的侵入。于是有了方案二，在方案二中，启动一个订阅程序去订阅数据库的binlog，获得需要操作的数据。在应用程序中，另起一段程序，获得这个订阅程序传来的信息，进行删除缓存操作。

方案二：

（1）更新数据库数据
（2）数据库会将操作信息写入binlog日志当中
（3）订阅程序提取出所需要的数据以及key
（4）另起一段非业务代码，获得该信息
（5）尝试删除缓存操作，发现删除失败
（6）将这些信息发送至消息队列
（7）重新从消息队列中获得该数据，重试操作。

上述的订阅binlog程序在mysql中有现成的中间件叫canal，可以完成订阅binlog日志的功能。

总结

说了这么多，到底哪个更好呢？

1.如果你的数据库没有读写分离，缓存的是单条数据的缓存，例如用户的信息，订单信息等。选择先删除缓存，再更新数据库。

public void write(String key,Object data){begin//用悲观锁锁住数据select .... for updateredis.delKey(key);db.updateData(data);conmit}

2.读写分离，分表分库的情况下，推荐使用先更新数据库，再删缓存

无论是先更新数据库，再删缓存还是先删除缓存，再更新数据库，都涉及二次缓存删除可靠性的问题，先更新数据库，再删缓存最终缓存得到的脏数据概率更低

3.缓存信息是经过大量计算出来的，例如公司运营数据，报表数据。

这种情况要考虑你的业务的正确性，如果经过大量计算出来缓存到内存的内容经常需要变更，那为什么需要缓存呢？

最后再切记
一开始考虑去缓存经常被更新的数据，从业务上就是一个错误

参考

http://blog.jobbole.com/113992/