使用分布式缓存会遇到的问题汇总

2022-03-09 11:47:05 浏览数 (1)

前言

目前工作中用到的分布式缓存技术有redis和memcached两种，缓存的目的是为了在高并发系统中有效降低DB的压力，但是在使用的时候可能会因为缓存结构设计不当造成一些问题，这里会把可能遇到的坑整理出来，方便日后查找。

业务系统读写缓存的3 种模式

  • Cache Aside（旁路缓存）
  • Read/Write Through（读写穿透）
  • Write Behind Caching（异步缓存写入）

Cache Aside模式

1.Write: 更新 DB 后，直接将 key 从 cache 中删除，然后由 DB 驱动缓存数据的更新；

2.Read: 是先读 cache，如果 cache 没有，则读 DB，同时将从 DB 中读取的数据回写到 cache。

特点：

确保数据以DB 结果为准

适用场景：

对数据一致性要求比较高的业务，或者是缓存数据更新比较复杂的业务，比如需要通过多个原始数据进行计算后设置的缓存数据

Read/Write Through模式

1. Write: 存储服务收到业务应用的写请求时，会首先查 cache，如果数据在 cache 中不存在，则只更新 DB，如果数据在 cache 中存在，则先更新 cache，然后更新 DB。

2. Read: 存储服务收到读请求时，如果命中 cache 直接返回，否则先从 DB 加载，回写到 cache 后返回响应。

特点：

  • 存储服务封装了所有的数据处理细节，业务应用端代码只用关注业务逻辑本身，系统的隔离性更佳。
  • 进行写操作时，如果 cache 中没有数据则不更新，有缓存数据才更新，内存效率更高。

适用场景：

用户最新Feed列表

Write Behind Caching模式

1.Write: 只更新缓存，不直接更新 DB，而是改为异步批量的方式来更新 DB

2.Read: 如果命中 cache 直接返回，否则先从 DB 加载，回写到 cache 后返回响应。

特点：

写性能最高，定期异步刷新，存在数据丢失概率

适用场景：

适合变更频率特别高，但对一致性要求不太高的业务，特别是可以合并写请求的业务，比如对一些计数业务

一. 常用的两种缓存技术的服务端特点

1. Memcache服务端

Memcache（下面简称mc）服务端是没有集群概念的，所有的存储分发全部交由mc client去做，我这里使用的是xmemcached，这个客户端支持多种哈希策略，默认使用key与实例数取模来进行简单的数据分片。

这种分片方式会导致一个问题，那就是新增或者减少节点后会在一瞬间导致大量key失效，最终导致缓存雪崩的发生，给DB带来巨大压力，所以我们的mc client启用了xmemcached的一致性哈希算法来进行数据分片：

代码语言：javascript复制
XMemcachedClientBuilder builder = new XMemcachedClientBuilder(AddrUtil.getAddresses(servers));
builder.setOpTimeout(opTimeout);
builder.setConnectTimeout(connectTimeout);
builder.setTranscoder(transcoder);
builder.setConnectionPoolSize(connectPoolSize);
builder.setKeyProvider(keyProvider);
builder.setSessionLocator(new KetamaMemcachedSessionLocator()); //启用ketama一致性哈希算法进行数据分片

根据一致性哈希算法的特性，在新增或减少mc的节点只会影响较少一部分的数据。但这种模式下也意味着分配不均匀，新增的节点可能并不能及时达到均摊数据的效果，不过mc采用了虚拟节点的方式来优化原始一致性哈希算法（由ketama算法控制实现），实现了新增物理节点后也可以均摊数据的能力。

最后，mc服务端是多线程处理模式，mc一个value最大只能存储1M的数据，所有的k-v过期后不会自动移除，而是下次访问时与当前时间做对比，过期时间小于当前时间则删除，如果一个k-v产生后就没有再次访问了，那么数据将会一直存在在内存中，直到触发LRU。

2. Redis服务端

redis服务端有集群模式，key的路由交由redis服务端做处理，除此之外redis有主从配置以达到服务高可用。

redis服务端是单线程处理模式，这意味着如果有一个指令导致redis处理过慢，会阻塞其他指令的响应，所以redis禁止在生产环境使用重量级操作（例如keys，再例如缓存较大的值导致传输过慢）

redis服务端并没有采用一致性哈希来做数据分片，而是采用了哈希槽的概念来做数据分片，一个redis cluster整体拥有16384个哈希槽（slot），这些哈希槽按照编号区间的不同，分布在不同节点上，然后一个key进来，通过内部哈希算法（CRC16(key)）计算出槽位置;

然后将数据存放进对应的哈希槽对应的空间，redis在新增或者减少节点时，其实就是对这些哈希槽进行重新分配，以新增节点为例，新增节点意味着原先节点上的哈希槽区间会相对缩小，被减去的那些哈希槽里的数据将会顺延至下一个对应节点，这个过程由redis服务端协调完成，过程如下：

“ 迁移过程是以槽为单位，将槽内的key按批次进行迁移的（migrate）。

二. 缓存结构化选型

mc提供简单的k-v存储，value最大可以存储1M的数据，多线程处理模式，不会出现因为某次处理慢而导致其他请求排队等待的情况，适合存储数据的文本信息。

redis提供丰富的数据结构，服务端是单线程处理模式，虽然处理速度很快，但是如果有一次查询出现瓶颈，那么后续的操作将被阻塞，所以相比k-v这种可能因为数据过大而导致网络交互产生瓶颈的结构来说，它更适合处理一些数据结构的查询、排序、分页等操作，这些操作往往复杂度不高，且耗时极短，因此不太可能会阻塞redis的处理。

使用这两种缓存服务来构建我们的缓存数据，目前提倡所有数据按照标志性字段（例如id）组成自己的信息缓存存储，这个一般由mc的k-v结构来完成存储。

而redis提供了很多好用的数据结构，一般构建结构化的缓存数据都使用redis的数据结构来保存数据的基本结构，然后组装数据时根据redis里缓存的标志性字段去mc里查询具体数据，例如一个排行榜接口的获取：

上图redis提供排行榜的结构存储，排行榜里存储的是id和score，通过redis可以获取到结构内所有信息的id，然后利用获得的id可以从mc中查出详细信息，redis在这个过程负责分页、排序，mc则负责存储详细信息。

上面是比较合适的缓存做法，建议每条数据都有一个自己的基本缓存数据，这样便于管理，而不是把一个接口的巨大结构完全缓存到mc或者redis里，这样划分太粗，日积月累下来每个接口或者巨大方法都有一个缓存，key会越来越多，越来越杂。

三. Redis构造大索引回源问题

Redis如果做缓存使用，始终会有过期时间存在，如果到了过期时间，使用redis构建的索引将会消失，这个时候回源，如果存在大批量的数据需要构建redis索引，就会存在回源方法过慢的问题，这里以某个评论系统为例;

评论系统采用有序集合作为评论列表的索引，存储的是评论id，用于排序的score值则按照排序维度拆分，比如发布时间、点赞数等，这也意味着一个资源下的评论列表根据排序维度不同存在着多个redis索引列表，而具体评论内容存mc，正常情况下结构如下：

上面是正常触发一个资源的评论区，每次触发读缓存，都会顺带延长一次缓存的过期时间，这样可以保证较热的内容不会轻易过期，但是如果一个评论区时间过长没人访问过，redis索引就会过期，如果一个评论区有数万条评论数据，长时间没人访问，突然有人过去考古，那么在回源构建redis索引时会很缓慢，如果没有控制措施，还会造成下面缓存穿透的问题，从而导致这种重量级操作反复被多个线程执行，对DB造成巨大压力。

对于上面这种回源构建索引缓慢的问题，处理方式可以是下面这样：

相比直接执行回源方法，这种通过消息队列构造redis索引的方法更加适合，首先仅构建单页或者前面几页的索引数据，然后通过队列通知job（这里可以理解为消费者）进行完整索引构造，当然，这只适合对一致性要求不高的场景。

四. 一致性问题

一般情况下缓存内的数据要和数据库源数据保持一致性，这就涉及到更新DB后主动失效缓存策略（通俗叫法：清缓存），大部分会经过如下过程：

假如现在有两个服务，服务A和服务B，现在假设服务A会触发某个数据的写操作，而服务B则是只读程序，数据被缓存在一个Cache服务内，现在假如服务A更新了一次数据库，那么结合上图得出以下流程：

  1. 服务A触发更新数据库的操作
  2. 更新完成后删除数据对应的缓存key
  3. 只读服务（服务B）读取缓存时发现缓存miss
  4. 服务B读取数据库源信息
  5. 写入缓存并返回对应信息

这个过程乍一看是没什么问题的，但是往往多线程运转的程序会导致意想不到的结果，现在来想象下服务A和服务B被多个线程运行着，这个时候重复上述过程，就会存在一致性问题。

1. 并发读写导致的一致性问题

  1. 运行着服务A的线程1首先修改数据，然后删除缓存
  2. 运行着服务B的线程3读缓存时发现缓存miss，开始读取DB中的源数据，需要注意的是这次读出来的数据是线程1修改后的那份
  3. 这个时候运行着服务A的线程2上线，开始修改数据库，同样的，删除缓存，需要注意的是，这次删除的其实是一个空缓存，没有意义，因为本来线程3那边还没有回源完成
  4. 运行着服务B的线程3将读到的由线程1写的那份数据回写进Cache

上述过程完成后，最终结果就是DB里保存的最终数据是线程2写进去的那份，而Cache经过线程3的回源后保存的却是线程1写的那份数据，不一致问题出现。

2. 主从同步延时导致的一致性问题

这种情况要稍微修改下程序的流程图，多出一个从库：

现在读操作走从库，这个时候如果在主库写操作删除缓存后，由于主从同步有可能稍微慢于回源流程触发，回源时读取从库仍然会读到老数据。

3. 缓存污染导致的一致性问题

每次做新需求时更新了原有的缓存结构，或去除几个属性，或新增几个属性，假如新需求是给某个缓存对象O新增一个属性B，如果新逻辑已经在预发或者处于灰度中，就会出现生产环境回源后的缓存数据没有B属性的情况，而预发和灰度时，新逻辑需要使用B属性，就会导致生产&预发缓存污染。过程大致如下：

五. 如何应对缓存一致性问题？

缓存一致性问题大致分为以下几个解决方案，下面一一介绍。

1. binlog 消息队列 消费者del cache

上图是现在常用的清缓存策略，每次表发生变动，通过mysql产生的binlog去给消息队列发送变动消息，这里监听DB变动的服务由canal提供，canal可以简单理解成一个实现了mysql通信协议的从库，通过mysql主从配置完成binlog同步，且它只接收binlog，通过这种机制，就可以很自然的监听数据库表数据变动了，可以保证每次数据库发生的变动，都会被顺序发往消费者去清除对应的缓存key。

2. 从库binlog 消息队列 消费者del cache

上面的过程能保证写库时清缓存的顺序问题，看似并没有什么问题，但是生产环境往往存在主从分离的情况，也就是说上面的图中如果回源时读的是从库，那上面的过程仍然是存在一致性问题的：

“ 从库延迟导致的脏读问题，如何解决这类问题呢？

只需要将canal监听的数据库设置成从库即可，保证在canal推送过来消息时，所有的从库和主库完全一致，不过这只针对一主一从的情况，如果一主多从，且回源读取的从库有多个，那么上述也是存在一定的风险的（一主多从需要订阅每个从节点的binlog，找出最后发过来的那个节点，然后清缓存，确保所有的从节点全部和主节点一致）。

不过，正常情况下，从库binlog的同步速度都要比canal发消息快，因为canal要接收binlog，然后组装数据变动实体（这一步是有额外开销的），然后通过消息队列推送给各消费者（这一步也是有开销的），所以即便是订阅的master库的表变更，出问题的概率也极小。

3. 更新后key升级

针对上面的一致性问题（缓存污染），修改某个缓存结构可能导致在预发或者灰度中状态时和实际生产环境的缓存相互污染，这个时候建议每次更新结构时都进行一次key升级（比如在原有的key名称基础上加上_v2的后缀）。

“ ⚡⚡⚡binlog是否真的是准确无误的呢？⚡⚡⚡

并不是，比如上面的情况：

  1. 首先线程1走到服务A，写DB，发binlog删除缓存
  2. 然后线程3运行的服务B这时cache miss，然后读取DB回源（这时读到的数据是线程1写入的那份数据）
  3. 此时线程2再次触发服务A写DB，同样发送binlog删除缓存
  4. 最后线程3把读到的数据写入cache，最终导致DB里存储的是线程2写入的数据，但是cache里存储的却是线程1写入的数据，不一致达成

这种情况比较难以触发，因为极少会出现线程3那里写cache的动作会晚于第二次binlog发送的，除非在回源时做了别的带有阻塞性质的操作;

所以根据现有的策略，没有特别完美的解决方案，只能尽可能保证一致性，但由于实际生产环境，处于多线程并发读写的环境，即便有binlog做最终的保证，也不能保证最后回源方法写缓存那里的顺序性。除非回源全部交由binlog消费者来做，不过这本就不太现实，这样等于说服务B没有回源方法了。

针对这个问题，出现概率最大的就是那种写并发概率很大的情况，这个时候伴随而来的还有命中率问题。

六. 命中率问题

通过前面的流程，抛开特殊因素，已经解决了一致性的问题，但随着清缓存而来的另一个问题就是命中率问题。

比如一个数据变更过于频繁，以至于产生过多的binlog消息，这个时候每次都会触发消费者的清缓存操作，这样的话缓存的命中率会瞬间下降，导致大部分用户访问直接访问DB；

而且这种频繁变更的数据还会加大问题①出现的概率，所以针对这种频繁变更的数据，不再删除缓存key，而是直接在binlog消费者那里直接回源更新缓存，这样即便表频繁变更，用户访问时每次都是消费者更新好的那份缓存数据，只是这时候消费者要严格按照消息顺序来处理；

否则也会有写脏的危险，比如开两个线程同时消费binlog消息，线程1接收到了第一次数据变更的binlog，而线程2接收到了第二次数据变更的binlog，这时线程1读出数据（旧数据），线程2读出数据（新数据）更新缓存，然后线程1再执行更新，这时缓存又会被写脏；

所以为了保证消费顺序，必须是单线程处理，如果想要启用多线程均摊压力，可以利用key、id等标识性字段做任务分组，这样同一个id的binlog消息始终会被同一个线程执行。

七. 缓存穿透（key不存在，直接穿透过缓存）

1. 什么是缓存穿透？

正常情况下用户请求一个数据时会携带标记性的参数（比如id），而我们的缓存key则会以这些标记性的参数来划分不同的cache value，然后我们根据这些参数去查缓存，查到就返回，否则回源，然后写入cache服务后返回。

这个过程看起来也没什么问题，但是某些情况下，根据带进来的参数，在数据库里并不能找到对应的信息，这个时候每次带有这种参数的请求，都会走到数据库回源，这种现象叫做缓存穿透，比较典型的出现这种问题的情况有：

  1. 恶意攻击或者爬虫，携带数据库里本就不存在的数据做参数回源
  2. 公司内部别的业务方调用我方的接口时，由于沟通不当或其他原因导致的参数大量误传
  3. 客户端bug导致的参数大量误传

2. 如何解决缓存穿透问题？

  • 回源查不到信息时直接缓存空数据（注意：空数据缓存的过期时间要尽可能小，防止无意义内容过多占用Cache内存），这样即便是有参数误传、恶意攻击等情况，也不会每次都打进DB。
  • key规则校验：按照业务内自己的估算，合理的id大致在什么范围内，超过了某个阈值直接返回空。
  • 使用布隆过滤器判断key是否存在
  • 限流

八. 缓存击穿（热点key，由点到面击溃数据库）

1. 什么是缓存击穿？

缓存击穿是指在一个key失效后，大量请求打进回源方法，多线程并发回源的问题。

这种情况在少量访问时不能算作一个问题，但是当一个热点key失效后，就会发生回源时涌进过多流量，全部打在DB上，这样会导致DB在这一时刻压力剧增。

2. 如何解决缓存击穿？

  • 回源方法内追加互斥锁：这个可以避免多次回源，但是n台实例群模式下，仍然会存在实例并发回源的情况，这个量级相比之前大量打进，已经大量降低了。
  • 回源方法内追加分布式锁：这个可以完全避免上面多实例下并发回源的情况，但是缺点也很明显，那就是又引入了一个新的服务，这意味着发生异常的风险会加大。
  • 设置热点数据永远不过期
  • 限流

九. 缓存雪崩

1. 什么是缓存雪崩？

缓存雪崩是指缓存数据某一时刻出现大量失效的情况，所有请求全部打进DB，导致短期内DB负载暴增的问题，一般来说造成缓存雪崩有以下几种情况：

  1. 缓存服务扩缩容：这个是由缓存的数据分片策略的而导致的，如果采用简单的取模运算进行数据分片，那么服务端扩缩容就会导致雪崩的发生。
  2. 缓存服务宕机：某一时刻缓存服务器出现大量宕机的情况，导致缓存服务不可用，根据现有的实现，是直接打到DB上的。

2. 如何避免雪崩的发生？

  • 设置随机过期时间，避免大量key同时失效
  • 数据分片策略调整：调整缓存服务器的分片策略，比如上面第一部分所讲的，给mc开启一致性哈希算法的分片策略，防止缓存服务端扩缩容后缓存数据大量不可用。
  • 回源限流：如果缓存服务真的挂掉了，请求全打在DB上，以至于超出了DB所能承受之重，这个时候建议回源时进行整体限流，被限到的请求紫自动走降级逻辑，或者直接报错。

布隆过滤器解决缓存穿透的问题

应用

布隆过滤器的巨大用处就是，能够迅速判断一个元素是否在一个集合中。因此他有如下三个使用场景:

  1. 网页爬虫对URL的去重，避免爬取相同的URL地址
  2. 反垃圾邮件，从数十亿个垃圾邮件列表中判断某邮箱是否垃圾邮箱（同理，垃圾短信）
  3. 缓存穿透，将所有可能存在的数据缓存放到布隆过滤器中，当黑客访问不存在的缓存时迅速返回避免缓存及DB挂掉。

原理

其内部维护一个全为0的bit数组，需要说明的是，布隆过滤器有一个误判率的概念，误判率越低，则数组越长，所占空间越大。误判率越高则数组越小，所占的空间越小。

假设，根据误判率，我们生成一个10位的bit数组，以及2个hash函数（(f_1,f_2)），如下图所示(生成的数组的位数和hash函数的数量，我们不用去关心是如何生成的，有数学论文进行过专业的证明)。

假设输入集合为((N_1,N_2)),经过计算(f_1(N_1))得到的数值得为2，(f_2(N_1))得到的数值为5，则将数组下标为2和下表为5的位置置为1，如下图所示

同理，经过计算(f_1(N_2))得到的数值得为3，(f_2(N_2))得到的数值为6，则将数组下标为3和下表为6的位置置为1，如下图所示

这个时候，我们有第三个数(N_3)，我们判断(N_3)在不在集合((N_1,N_2))中，就进行(f_1(N_3)，f_2(N_3))的计算

  1. 若值恰巧都位于上图的红色位置中，我们则认为，(N_3)在集合((N_1,N_2))中
  2. 若值有一个不位于上图的红色位置中，我们则认为，(N_3)不在集合((N_1,N_2))中

特点

从容器的角度来说：

  • 如果布隆过滤器判断元素在集合中存在，不一定存在
  • 如果布隆过滤器判断不存在，一定不存在

从元素的角度来说：

  • 如果元素实际存在，布隆过滤器一定判断存在
  • 如果元素实际不存在，布隆过滤器可能判断存在

https://www.jianshu.com/p/744a89307c2d

https://blog.csdn.net/qq_40837310/article/details/110421287

十. 热key问题

1. 什么是热key问题？

了解了缓存服务端的实现，可以知道某一个确定的key始终会落到某一台服务器上，如果某个key在生产环境被大量访问，就导致了某个缓存服务节点流量暴增，等访问超出单节点负载，就可能会出现单点故障，单点故障后转移该key的数据到其他节点，单点问题依旧存在，则可能继续会让被转移到的节点也出现故障，最终影响整个缓存服务集群。

2. 如何解决热key问题？

  1. 多缓存副本：预先感知到发生热点访问的key，生成多个副本key，这样可以保证热点key会被多个缓存服务器持有，然后回源方法公用一个，请求时按照一定的算法随机访问某个副本key。
  2. 本地缓存：针对热点key外面包一层短存活期的本地缓存，用于缓冲热点服务器的压力。
  3. 利用大数据找出Hot key，将这些Hot key 进行分散处理，比如一个Hot key 名字叫 hotkey，可以被分散为 hotkey#1、hotkey#2、hotkey#3，……hotkey#n，这 n 个 key 分散存在多个缓存节点，然后 client 端请求时，随机访问其中某个后缀的 hotkey，这样就可以把热 key 的请求打散，避免一个缓存节点过载。
  4. 如果热 key 较多，还可以通过监控体系对缓存的 SLA 实时监控，通过快速扩容来减少Hot key 的冲击。

十一.Big key

问题描述：

在缓存访问时，部分 Key 的 Value 过大，读写、加载易超时的现象。

业务场景：

互联网系统中需要保存用户最新1万个粉丝的业务，一个用户个人信息缓存，包括基本资料、关系图谱计数、发 feed 统计等，微博用户发表 1千字甚至更长的微博内容

解决方案：

1.如果数据存在 memcached 中，可以设计一个缓存阀值，当 value 的长度超过阀值，则对内容启用压缩。

2.如果数据存在 Redis 中，对Big key拆分，如下：

big list： list1、list2、...listN

big hash：可以做二次的hash，例如hash0

日期：key20190320、key20190321、key_20190322

3. 对Big key设置较长的过期时间，缓存内部在淘汰 key 时，同等条件下，尽量不淘汰这些大 key

参考：https://mp.weixin.qq.com/s/NcV05_XQNz-OBjhgIGxV7Q

云数据库Redis® 缓存 memcached 数据结构 ide

0 人点赞