数据缓存层

Ⅰ 该怎么解决 Redis 缓存穿透和缓存雪崩问题

缓存雪崩： 由于缓存层承载着大量请求，有效地 保护了存储层，但是如果缓存层由于某些原因不能提供服务，比如 Redis 节点挂掉了，热点 key 全部失效了，在这些情况下，所有的请求都会直接请求到数据库，可能会造成数据库宕机的情况。
预防和解决缓存雪崩问题，可以从以下三个方面进行着手：
1、使用 Redis 高可用架构：使用 Redis 集群来保证 Redis 服务不会挂掉
2、缓存时间不一致： 给缓存的失效时间，加上一个随机值，避免集体失效
3、限流降级策略：有一定的备案，比如个性推荐服务不可用了，换成热点数据推荐服务
缓存穿透： 缓存穿透是指查询一个根本不存在的数据，这样的数据肯定不在缓存中，这会导致请求全部落到数据库上，有可能出现数据库宕机的情况。
预防和解决缓存穿透问题，可以考虑以下两种方法：
1、缓存空对象： 将空值缓存起来，但是这样就有一个问题，大量无效的空值将占用空间，非常浪费。
2、布隆过滤器拦截： 将所有可能的查询key 先映射到布隆过滤器中，查询时先判断key是否存在布隆过滤器中，存在才继续向下执行，如果不存在，则直接返回。布隆过滤器有一定的误判，所以需要你的业务允许一定的容错性。

Ⅱ php 高并发解决思路解决方案

php 高并发解决思路解决方案，如何应对网站大流量高并发情况。本文为大家总结了常用的处理方式，但不是细节，后续一系列细节教程给出。希望大家喜欢。

一 高并发的概念

在互联网时代，并发，高并发通常是指并发访问。也就是在某个时间点，有多少个访问同时到来。

二 高并发架构相关概念

1、QPS (每秒查询率) : 每秒钟请求或者查询的数量，在互联网领域，指每秒响应请求数(指 HTTP 请求)

2、PV（Page View）：综合浏览量，即页面浏览量或者点击量，一个访客在 24 小时内访问的页面数量

--注：同一个人浏览你的网站的同一页面，只记做一次 pv

3、吞吐量（fetches/sec） ：单位时间内处理的请求数量 （通常由 QPS 和并发数决定）

4、响应时间：从请求发出到收到响应花费的时间

5、独立访客（UV）：一定时间范围内，相同访客多次访问网站，只计算为 1 个独立访客

6、带宽：计算带宽需关注两个指标，峰值流量和页面的平均大小

7、日网站带宽： PV/统计时间（换算到秒） * 平均页面大小（kb）* 8

三 需要注意点：

1、QPS 不等于并发连接数（QPS 是每秒 HTTP 请求数量，并发连接数是系统同时处理的请求数量）

2、峰值每秒请求数（QPS）= （总 PV 数*80%）/ （六小时秒数*20%）【代表 80%的访问量都集中在 20%的时间内】

3、压力测试： 测试能承受的最大并发数 以及测试最大承受的 QPS 值

4、常用的性能测试工具【ab，wrk，httpload，Web Bench，Siege，Apache JMeter】

四 优化

1、当 QPS 小于 50 时

优化方案:为一般小型网站,不用考虑优化

2、当 QPS 达到 100 时,遇到数据查询瓶颈

优化方案: 数据库缓存层,数据库的负载均衡

3、当 QPS 达到 800 时, 遇到带宽瓶颈

优化方案:CDN 加速,负载均衡

4、当 QPS 达到 1000 时

优化方案: 做 html 静态缓存

5、当 QPS 达到 2000 时

优化方案: 做业务分离,分布式存储

五、高并发解决方案案例:

1、流量优化

防盗链处理(去除恶意请求)

2、前端优化

(1) 减少 HTTP 请求[将 css,js 等合并]

(2) 添加异步请求(先不将所有数据都展示给用户,用户触发某个事件,才会异步请求数据)

(3) 启用浏览器缓存和文件压缩

(4) CDN 加速

(5) 建立独立的图片服务器(减少 I/O)

3、服务端优化

(1) 页面静态化

(2) 并发处理

(3) 队列处理

4、数据库优化

(1) 数据库缓存

(2) 分库分表,分区

(3) 读写分离

(4) 负载均衡

5、web 服务器优化

(1) nginx 反向代理实现负载均衡

(2) lvs 实现负载均衡

Ⅲ redis一般用来干嘛

redis是一个单线程的NoSQL数据库，主要用来做数据缓存，一般大型网站的应用和数据库之间的那一层就是Redis。比如京东商城的页面查找功能，用户接触到的查询的第一层就是Redis数据缓存层，缓存中找不到的数据，再进入数据库查询。Redis中缓存热点数据，能够保护数据库，提高查询效率。

NoSQL，泛指非关系型的数据库。随着互联网web2.0网站的兴起，传统的关系数据库在处理web2.0网站，特别是超大规模和高并发的SNS类型的web2.0纯动态网站已经显得力不从心，出现了很多难以克服的问题，而非关系型的数据库则由于其本身的特点得到了非常迅速的发展。NoSQL数据库的产生就是为了解决大规模数据集合多重数据种类带来的挑战，特别是大数据应用难题。

Ⅳ Ceph 分层缓存--Tiering Cache

原文来自Ceph官方文档： CACHE TIERING

部分摘抄自Ceph中国社区翻译文档： 分级缓存

    分层缓存为ceph客户端中的某些存放在存储层的数据提供更好的IO性能。分级缓存需创建一个由高速而昂贵存储设备（如 SSD ）组成的存储池、作为缓存层，以及一个相对低速/廉价设备组成的后端存储池（或纠删码编码的）、作为经济存储层。Ceph 的对象处理器决定往哪里存储对象，分级代理决定何时把缓存内的对象刷回后端存储层；所以缓存层和后端存储层对 Ceph 客户端来说是完全透明的。

    缓存代理层管理着数据在缓存层和存储层之间的自动迁移。但是, 管理员也可以通过配置来干预迁移规则， 下面是对两个主要场景的介绍:

Writeback Mode： 当管理员将缓存层配置成回写模式, Ceph客户端将数据写入缓存层，并接收返回的ACK。同时，写入缓存层的数据迁移到存储层，  然后从缓存层刷掉。 直观的看， 缓存层在存储层之前。 当Ceph客户端需要存在于存储层的数据时， 缓存层代理会把这些数据迁移到缓存层，然后再发往 Ceph 客户端。因此，Ceph 客户端将与缓存层进行 I/O 操作，直到数据不再被读写。此模式对于易变数据来说较理想（如照片/视频编辑、事务数据等）。

Read-proxy Mode： 这个模式将使用一些已经存在于缓存层的数据，但是，如果数据不在缓存层，请求将被代理转发到底层。这个模式对于从回写模式过渡到禁用缓存非常有用的， 因为它润需负载一直工作到缓存干涸，不再向缓存添加任何数据。

  如果负载过多，分层缓存会降低性能。用户在使用以下特性时需要极其谨慎。

Workload dependent : 缓存是否能提升性能，高度依赖于负载能力。因为将数据移入或移除缓存会导致额外的开销，它只在对数据集的访问有大的偏离时有影响。例如, 众多的请求访问小数量的objects，这时，你的缓存池需要非常大，才能在处理所有请求时，避免数据过渡。

Difficult to benchmark : 用户使用评测性能时，大部分的关于分层缓存bechmarks测试结果，将会是一个糟糕的结果。其中部分原因是很少的bechmarks倾斜于一组小的对象集合的请求 ， 这会使缓存经过很长时间后才能“活跃起来”，并且这种“活跃起来”会导致高昂的开销。

Usually slower : 对于并没有友好使用分级缓存的工作负载，性能普遍低于一个没使用分级缓存的普通rados池。

librados object enumeration : 对于librados级别的枚举对象API并不能连贯存在在这种情况中（The librados-level object enumeration API is not meant to be coherent in the presence of the case）。 如果你的应用直接使用rados，并且依赖于枚举对象，分级缓存不能向期待的那样工作. (对于RGW, RBD, or CephFS，没有这个问题)

Complexity : 在使用RADOS集群时，使用分级缓存意味着大量的额外器械和复杂性。这会增加你遇到未知的BUG（可能其他人未遇到过）的可能性， 并且使你的部署拥有更大的风险。

RGW time-skewed : 如果RGW工作中遇到的大部分操作是朝向最近写入的数据，一个简单的分级缓存可以工作得很好。

    下面的配置使用分层缓存效果不佳。

RBD with replicated cache and erasure-coded base : 这是一个普遍的需求, 但是通常不能很好工作。即使合理的倾斜工作负载，仍然会遇到一些对于冷门object的写操作的情况，并且由于纠删码类型的池还不支持轻微的读写操作，为了适应一些小的写入操作（通常4kb），整个object块（通常4MB）必须被全部迁移到缓存 。只有少数用户成功的应用了这种部署方式，并且这种部署方案只能为他们工作是因为他们的数据是极其“冷门”的（例如备份），并且他们对于性能并不敏感。

RBD with replicated cache and base : 在使用备份类型为基础层时比以纠删码为基础层时，RBD的表现更为良好， 但是它在工作负载中仍然依赖于大量的倾斜，并且很难验证。用户需要对他们的工作负载有更好的理解， 并且需要仔细调整分层缓存参数。

    为了建立分层缓存，你必须拥有两个存储池。一个作为后端存储，一个作为缓存。

    建立一个后端存储池包含两种场景：

标准存储 : 在这种场景中，这个池在Ceph存储集群中存储一个对象的多个副本。

纠删码: 在这种场景中，存储池用纠删码高效地存储数据，性能稍有损失。

    在标准存储场景中，你可以用 CRUSH 规则集来标识失败域（如 osd 、主机、机箱、机架、排等）。当规则集所涉及的所有驱动器规格、速度（转速和吞吐量）和类型相同时， OSD 守护进程运行得最优。创建规则集的详情见 CRUSH 图 。创建好规则集后，再创建后端存储池。

     在纠删码编码情景中，创建存储池时指定好参数就会自动生成合适的规则集，详情见 创建存储池 。

     在后续例子中，我们把cold-storage当作后端存储池。

Ⅳ CPU的一级缓存 二级缓存 是什么 意思啊

缓存大小也是cpu的重要指标之一，而且缓存的结构和大小对cpu速度的影响非常大，cpu内缓存的运行频率极高，一般是和处理器同频运作，工作效率远远大于系统内存和硬盘。实际工作时，cpu往往需要重复读取同样的数据块，而缓存容量的增大，可以大幅度提升cpu内部读取数据的命中率，而不用再到内存或者硬盘上寻找，以此提高系统性能。
l1
cache(一级缓存)是cpu第一层高速缓存，分为数据缓存和指令缓存。内置的l1高速缓存的容量和结构对cpu的性能影响较大，不过高速缓冲存储器均由静态ram组成，结构较复杂，在cpu管芯面积不能太大的情况下，l1级高速缓存的容量不可能做得太大。一般服务器cpu的l1缓存的容量通常在32—256kb。
l2
cache(二级缓存)是cpu的第二层高速缓存，分内部和外部两种芯片。内部的芯片二级缓存运行速度与主频相同，而外部的二级缓存则只有主频的一半。l2高速缓存容量也会影响cpu的性能，原则是越大越好，现在家庭用cpu容量最大的是512kb，而服务器和工作站上用cpu的l2高速缓存更高达256-1mb，有的高达2mb或者3mb。

Ⅵ 处理器中的一级二级三级缓存是什么意思

L1Cache(一级缓存）是CPU第一层高速缓存，分为数据缓存和指令缓存。内置的L1高速缓存的容量和结构对CPU的性能影响较大，不过高速缓冲存储器均由静态RAM组成，结构较复杂，在CPU管芯面积不能太大的情况下，L1级高速缓存的容量不可能做得太大。一般服务器CPU的L1缓存的容量通常在32－256KB。
L2Cache（二级缓存）是CPU的第二层高速缓存，分内部和外部两种芯片。内部的芯片二级缓存运行速度与主频相同，而外部的二级缓存则只有主频的一半。L2高速缓存容量也会影响CPU的性能，原则是越大越好，以前家庭用CPU容量最大的是512KB，笔记本电脑中也可以达到2M，而服务器和工作站上用CPU的L2高速缓存更高，可以达到8M以上。
L3Cache(三级缓存），分为两种，早期的是外置，内存延迟，同时提升大数据量计算时处理器的性能。降低内存延迟和提升大数据量计算能力对游戏都很有帮助。而在服务器领域增加L3缓存在性能方面仍然有显着的提升。比方具有较大L3缓存的配置利用物理内存会更有效，故它比较慢的磁盘I/O子系统可以处理更多的数据请求。具有较大L3缓存的处理器提供更有效的文件系统缓存行为及较短消息和处理器队列长度。

Ⅶ 电脑CPU所谓的，一级二级三级缓存分别在什么位置

CPU中缓存是为了加快CPU读取数据的速度，也是为了给内存一个缓冲期。因为CPU运算速度太快了，光靠内存读写完全跟不上，而CPU缓存的数据交换比内存快多了，大部分时候CPU可以直接从缓存读取数据，找不到的话再从内存读取，这样可以节省CPU读取内存数据时浪费的时间。

CPU缓存分为三类，一级缓存(L1)、二级缓存(L2)和三级缓存(L3)。CPU在实际数据读取中重要的却是一级缓存，因为一级缓存速度最快，二级缓存其次，三级缓存最慢，只是三级缓存的容量最大。

(7)数据缓存层扩展阅读：

一级缓存虽然速度最快，但容量最小，单位都是KB，不同CPU之间一级缓存没有差距，所以现在不怎么提了，二级缓存容量也不大，基本都是个位数MB，除了一些服务器CPU会有10几MB之外，现在CPU也不怎么提二级缓存。CPU读取缓存时会先从一级缓存开始，然是二级缓存，而读取二级缓存有时候会出现数据未命中的情况，这时候就需要从三级缓存读取。

但是要注意的是三级缓存越大并不一定说这个CPU性能就越强，因为三级缓存的容量还依靠CPU架构和工艺等方面的影响，如果是与架构工艺搭配升级的三级缓存，容量越大才会性能越高。

Ⅷ 如何保证数据库缓存的最终一致性

对于互联网业务来说，传统的直接访问数据库方式，主要通过数据分片、一主多从等方式来扛住读写流量，但随着数据量的积累和流量的激增，仅依赖数据库来承接所有流量，不仅成本高、效率低、而且还伴随着稳定性降低的风险。

鉴于大部分业务通常是读多写少（读取频率远远高于更新频率），甚至存在读操作数量高出写操作多个数量级的情况。因此， 在架构设计中，常采用增加缓存层来提高系统的响应能力 ，提升数据读写性能、减少数据库访问压力，从而提升业务的稳定性和访问体验。

根据 CAP 原理，分布式系统在可用性、一致性和分区容错性上无法兼得，通常由于分区容错无法避免，所以一致性和可用性难以同时成立。对于缓存系统来说， 如何保证其数据一致性是一个在应用缓存的同时不得不解决的问题 。

需要明确的是，缓存系统的数据一致性通常包括持久化层和缓存层的一致性、以及多级缓存之间的一致性，这里我们仅讨论前者。持久化层和缓存层的一致性问题也通常被称为双写一致性问题，“双写”意为数据既在数据库中保存一份，也在缓存中保存一份。

对于一致性来说，包含强一致性和弱一致性 ，强一致性保证写入后立即可以读取，弱一致性则不保证立即可以读取写入后的值，而是尽可能的保证在经过一定时间后可以读取到，在弱一致性中应用最为广泛的模型则是最终一致性模型，即保证在一定时间之后写入和读取达到一致的状态。对于应用缓存的大部分场景来说，追求的则是最终一致性，少部分对数据一致性要求极高的场景则会追求强一致性。

为了达到最终一致性，针对不同的场景，业界逐步形成了下面这几种应用缓存的策略。

— 1 —

Cache-Aside

Cache-Aside 意为旁路缓存模式，是应用最为广泛的一种缓存策略。下面的图示展示了它的读写流程，来看看它是如何保证最终一致性的。在读请求中，首先请求缓存，若缓存命中（cache hit），则直接返回缓存中的数据；若缓存未命中（cache miss），则查询数据库并将查询结果更新至缓存，然后返回查询出的数据（demand-filled look-aside ）。在写请求中，先更新数据库，再删除缓存（write-invalidate）。

1、为什么删除缓存，而不是更新缓存？

在 Cache-Aside 中，对于读请求的处理比较容易理解，但在写请求中，可能会有读者提出疑问，为什么要删除缓存，而不是更新缓存？站在符合直觉的角度来看，更新缓存是一个容易被理解的方案，但站在性能和安全的角度，更新缓存则可能会导致一些不好的后果。

首先是性能 ，当该缓存对应的结果需要消耗大量的计算过程才能得到时，比如需要访问多张数据库表并联合计算，那么在写操作中更新缓存的动作将会是一笔不小的开销。同时，当写操作较多时，可能也会存在刚更新的缓存还没有被读取到，又再次被更新的情况（这常被称为缓存扰动），显然，这样的更新是白白消耗机器性能的，会导致缓存利用率不高。

而等到读请求未命中缓存时再去更新，也符合懒加载的思路，需要时再进行计算。删除缓存的操作不仅是幂等的，可以在发生异常时重试，而且写-删除和读-更新在语义上更加对称。

其次是安全 ，在并发场景下，在写请求中更新缓存可能会引发数据的不一致问题。参考下面的图示，若存在两个来自不同线程的写请求，首先来自线程 1 的写请求更新了数据库（step 1），接着来自线程 2 的写请求再次更新了数据库（step 3），但由于网络延迟等原因，线程 1 可能会晚于线程 2 更新缓存（step 4 晚于 step 3），那么这样便会导致最终写入数据库的结果是来自线程 2 的新值，写入缓存的结果是来自线程 1 的旧值，即缓存落后于数据库，此时再有读请求命中缓存（step 5），读取到的便是旧值。

2、为什么先更新数据库，而不是先删除缓存？

另外，有读者也会对更新数据库和删除缓存的时序产生疑问，那么为什么不先删除缓存，再更新数据库呢？在单线程下，这种方案看似具有一定合理性，这种合理性体现在删除缓存成功。

但更新数据库失败的场景下，尽管缓存被删除了，下次读操作时，仍能将正确的数据写回缓存，相对于 Cache-Aside 中更新数据库成功，删除缓存失败的场景来说，先删除缓存的方案似乎更合理一些。那么，先删除缓存有什么问题呢？

问题仍然出现在并发场景下，首先来自线程 1 的写请求删除了缓存（step 1），接着来自线程 2 的读请求由于缓存的删除导致缓存未命中，根据 Cache-Aside 模式，线程 2 继而查询数据库（step 2），但由于写请求通常慢于读请求，线程 1 更新数据库的操作可能会晚于线程 2 查询数据库后更新缓存的操作（step 4 晚于 step 3），那么这样便会导致最终写入缓存的结果是来自线程 2 中查询到的旧值，而写入数据库的结果是来自线程 1 的新值，即缓存落后于数据库，此时再有读请求命中缓存（ step 5 ），读取到的便是旧值。

另外，先删除缓存，由于缓存中数据缺失，加剧数据库的请求压力，可能会增大缓存穿透出现的概率。

3、如果选择先删除缓存，再更新数据库，那如何解决一致性问题呢？

为了避免“先删除缓存，再更新数据库”这一方案在读写并发时可能带来的缓存脏数据，业界又提出了延时双删的策略，即在更新数据库之后，延迟一段时间再次删除缓存，为了保证第二次删除缓存的时间点在读请求更新缓存之后，这个延迟时间的经验值通常应稍大于业务中读请求的耗时。

延迟的实现可以在代码中 sleep 或采用延迟队列。显而易见的是，无论这个值如何预估，都很难和读请求的完成时间点准确衔接，这也是延时双删被诟病的主要原因。

4、那么 Cache-Aside 存在数据不一致的可能吗？

在 Cache-Aside 中，也存在数据不一致的可能性。在下面的读写并发场景下，首先来自线程 1 的读请求在未命中缓存的情况下查询数据库（step 1），接着来自线程 2 的写请求更新数据库（step 2），但由于一些极端原因，线程 1 中读请求的更新缓存操作晚于线程 2 中写请求的删除缓存的操作（step 4 晚于 step 3），那么这样便会导致最终写入缓存中的是来自线程 1 的旧值，而写入数据库中的是来自线程 2 的新值，即缓存落后于数据库，此时再有读请求命中缓存（step 5），读取到的便是旧值。

这种场景的出现，不仅需要缓存失效且读写并发执行，而且还需要读请求查询数据库的执行早于写请求更新数据库，同时读请求的执行完成晚于写请求。足以见得，这种 不一致场景产生的条件非常严格，在实际的生产中出现的可能性较小 。

除此之外，在并发环境下，Cache-Aside 中也存在读请求命中缓存的时间点在写请求更新数据库之后，删除缓存之前，这样也会导致读请求查询到的缓存落后于数据库的情况。

虽然在下一次读请求中，缓存会被更新，但如果业务层面对这种情况的容忍度较低，那么可以采用加锁在写请求中保证“更新数据库&删除缓存”的串行执行为原子性操作（同理也可对读请求中缓存的更新加锁）。 加锁势必会导致吞吐量的下降，故采取加锁的方案应该对性能的损耗有所预期。

— 2 —

补偿机制

我们在上面提到了，在 Cache-Aside 中可能存在更新数据库成功，但删除缓存失败的场景，如果发生这种情况，那么便会导致缓存中的数据落后于数据库，产生数据的不一致的问题。

其实，不仅 Cache-Aside 存在这样的问题，在延时双删等策略中也存在这样的问题。针对可能出现的删除失败问题，目前业界主要有以下几种补偿机制。

1、删除重试机制

由于同步重试删除在性能上会影响吞吐量，所以常通过引入消息队列，将删除失败的缓存对应的 key 放入消息队列中，在对应的消费者中获取删除失败的 key ，异步重试删除。这种方法在实现上相对简单，但由于删除失败后的逻辑需要基于业务代码的 trigger 来触发 ，对业务代码具有一定入侵性。

鉴于上述方案对业务代码具有一定入侵性，所以需要一种更加优雅的解决方案，让缓存删除失败的补偿机制运行在背后，尽量少的耦合于业务代码。一个简单的思路是通过后台任务使用更新时间戳或者版本作为对比获取数据库的增量数据更新至缓存中，这种方式在小规模数据的场景可以起到一定作用，但其扩展性、稳定性都有所欠缺。

一个相对成熟的方案是基于 MySQL 数据库增量日志进行解析和消费，这里较为流行的是阿里巴巴开源的作为 MySQL binlog 增量获取和解析的组件 canal（类似的开源组件还有 Maxwell、Databus 等）。

canal sever 模拟 MySQL slave 的交互协议，伪装为 MySQL slave，向 MySQL master 发送 mp 协议，MySQL master 收到 mp 请求，开始推送 binary log 给 slave （即 canal sever ），canal sever 解析 binary log 对象（原始为 byte 流），可由 canal client 拉取进行消费，同时 canal server 也默认支持将变更记录投递到 MQ 系统中，主动推送给其他系统进行消费。

在 ack 机制的加持下，不管是推送还是拉取，都可以有效的保证数据按照预期被消费。当前版本的 canal 支持的 MQ 有 Kafka 或者 RocketMQ。另外， canal 依赖 ZooKeeper 作为分布式协调组件来实现 HA ，canal 的 HA 分为两个部分：

那么，针对缓存的删除操作便可以在 canal client 或 consumer 中编写相关业务代码来完成。这样，结合数据库日志增量解析消费的方案以及 Cache-Aside 模型，在读请求中未命中缓存时更新缓存（通常这里会涉及到复杂的业务逻辑），在写请求更新数据库后删除缓存，并基于日志增量解析来补偿数据库更新时可能的缓存删除失败问题，在绝大多数场景下，可以有效的保证缓存的最终一致性。

另外需要注意的是，还应该隔离事务与缓存，确保数据库入库后再进行缓存的删除操作。 比如考虑到数据库的主从架构，主从同步及读从写主的场景下，可能会造成读取到从库的旧数据后便更新了缓存，导致缓存落后于数据库的问题，这就要求对缓存的删除应该确保在数据库操作完成之后。所以，基于 binlog 增量日志进行数据同步的方案，可以通过选择解析从节点的 binlog，来避免主从同步下删除缓存过早的问题。

3、数据传输服务 DTS

— 3 —

Read-Through

Read-Through 意为读穿透模式，它的流程和 Cache-Aside 类似，不同点在于 Read-Through 中多了一个访问控制层，读请求只和该访问控制层进行交互，而背后缓存命中与否的逻辑则由访问控制层与数据源进行交互，业务层的实现会更加简洁，并且对于缓存层及持久化层交互的封装程度更高，更易于移植。

— 4 —

Write-Through

Write-Through 意为直写模式，对于 Write-Through 直写模式来说，它也增加了访问控制层来提供更高程度的封装。不同于 Cache-Aside 的是，Write-Through 直写模式在写请求更新数据库之后，并不会删除缓存，而是更新缓存。

这种方式的 优势在于读请求过程简单 ，不需要查询数据库更新缓存等操作。但其劣势也非常明显，除了上面我们提到的更新数据库再更新缓存的弊端之外，这种方案还会造成更新效率低，并且两个写操作任何一次写失败都会造成数据不一致。

如果要使用这种方案， 最好可以将这两个操作作为事务处理，可以同时失败或者同时成功，支持回滚，并且防止并发环境下的不一致 。另外，为了防止缓存扰动的频发，也可以给缓存增加 TTL 来缓解。

站在可行性的角度，不管是 Write-Through 模式还是 Cache-Aside 模式，理想状况下都可以通过分布式事务保证缓存层数据与持久化层数据的一致性，但在实际项目中，大多都对一致性的要求存在一些宽容度，所以在方案上往往有所折衷。

Write-Through 直写模式适合写操作较多，并且对一致性要求较高的场景，在应用 Write-Through 模式时，也需要通过一定的补偿机制来解决它的问题。首先，在并发环境下，我们前面提到了先更新数据库，再更新缓存会导致缓存和数据库的不一致，那么先更新缓存，再更新数据库呢？

这样的操作时序仍然会导致下面这样线程 1 先更新缓存，最后更新数据库的情况，即由于线程 1 和 线程 2 的执行不确定性导致数据库和缓存的不一致。这种由于线程竞争导致的缓存不一致，可以通过分布式锁解决，保证对缓存和数据库的操作仅能由同一个线程完成。对于没有拿到锁的线程，一是通过锁的 timeout 时间进行控制，二是将请求暂存在消息队列中顺序消费。

在下面这种并发执行场景下，来自线程 1 的写请求更新了数据库，接着来自线程 2 的读请求命中缓存，接着线程 1 才更新缓存，这样便会导致线程 2 读取到的缓存落后于数据库。同理，先更新缓存后更新数据库在写请求和读请求并发时，也会出现类似的问题。面对这种场景，我们也可以加锁解决。

另在，在 Write-Through 模式下，不管是先更新缓存还是先更新数据库，都存在更新缓存或者更新数据库失败的情况，上面提到的重试机制和补偿机制在这里也是奏效的。

— 5 —

Write-Behind

Write behind 意为异步回写模式，它也具有类似 Read-Through/Write-Through 的访问控制层，不同的是，Write behind 在处理写请求时，只更新缓存而不更新数据库，对于数据库的更新，则是通过批量异步更新的方式进行的，批量写入的时间点可以选在数据库负载较低的时间进行。

在 Write-Behind 模式下，写请求延迟较低，减轻了数据库的压力，具有较好的吞吐性。但数据库和缓存的一致性较弱，比如当更新的数据还未被写入数据库时，直接从数据库中查询数据是落后于缓存的。同时，缓存的负载较大，如果缓存宕机会导致数据丢失，所以需要做好缓存的高可用。显然，Write behind 模式下适合大量写操作的场景，常用于电商秒杀场景中库存的扣减。

— 6 —

Write-Around

如果一些非核心业务，对一致性的要求较弱，可以选择在 cache aside 读模式下增加一个缓存过期时间，在写请求中仅仅更新数据库，不做任何删除或更新缓存的操作，这样，缓存仅能通过过期时间失效。这种方案实现简单，但缓存中的数据和数据库数据一致性较差，往往会造成用户的体验较差，应慎重选择。

— 7 —

总结

在解决缓存一致性的过程中，有多种途径可以保证缓存的最终一致性，应该根据场景来设计合适的方案，读多写少的场景下，可以选择采用“Cache-Aside 结合消费数据库日志做补偿”的方案，写多的场景下，可以选择采用“Write-Through 结合分布式锁”的方案 ，写多的极端场景下，可以选择采用“Write-Behind”的方案。

Ⅸ 什么是缓存数据缓存是什么意思

缓存（Cache memory）是硬盘控制器上的一块内存芯片，具有极快的存取速度，它是硬盘内部存储和外界接口之间的缓冲器。由于硬盘的内部数据传输速度和外界接口传输速度不同，缓存在其中起到一个缓冲的作用。缓存的大小与速度是直接关系到硬盘的传输速度的重要因素，能够大幅度地提高硬盘整体性能。当硬盘存取零碎数据时需要不断地在硬盘与内存之间交换数据，如果有大缓存，则可以将那些零碎数据暂存在缓存中，减小外系统的负荷，也提高了数据的传输速度。 x0dx0ax0dx0a硬盘的缓存主要起三种作用：一是预读取。当硬盘受到CPU指令控制开始读取数据时，硬盘上的控制芯片会控制磁头把正在读取的簇的下一个或者几个簇中的数据读到缓存中（由于硬盘上数据存储时是比较连续的，所以读取命中率较高），当需要读取下一个或者几个簇中的数据的时候，硬盘则不需要再次读取数据，直接把缓存中的数据传输到内存中就可以了，由于缓存的速度远远高于磁头读写的速度，所以能够达到明显改善性能的目的；二是对写入动作进行缓存。当硬盘接到写入数据的指令之后，并不会马上将数据写入到盘片上，而是先暂时存储在缓存里，然后发送一个“数据已写入”的信号给系统，这时系统就会认为数据已经写入，并继续执行下面的工作，而硬盘则在空闲（不进行读取或写入的时候）时再将缓存中的数据写入到盘片上。虽然对于写入数据的性能有一定提升，但也不可避免地带来了安全隐患——如果数据还在缓存里的时候突然掉电，那么这些数据就会丢失。对于这个问题，硬盘厂商们自然也有解决办法：掉电时，磁头会借助惯性将缓存中的数据写入零磁道以外的暂存区域，等到下次启动时再将这些数据写入目的地；第三个作用就是临时存储最近访问过的数据。有时候，某些数据是会经常需要访问的，硬盘内部的缓存会将读取比较频繁的一些数据存储在缓存中，再次读取时就可以直接从缓存中直接传输。 x0dx0ax0dx0a缓存容量的大小不同品牌、不同型号的产品各不相同，早期的硬盘缓存基本都很小，只有几百KB，已无法满足用户的需求。2MB和8MB缓存是现今主流硬盘所采用，而在服务器或特殊应用领域中还有缓存容量更大的产品，甚至达到了16MB、64MB等。 x0dx0ax0dx0a大容量的缓存虽然可以在硬盘进行读写工作状态下，让更多的数据存储在缓存中，以提高硬盘的访问速度，但并不意味着缓存越大就越出众。缓存的应用存在一个算法的问题，即便缓存容量很大，而没有一个高效率的算法，那将导致应用中缓存数据的命中率偏低，无法有效发挥出大容量缓存的优势。算法是和缓存容量相辅相成，大容量的缓存需要更为有效率的算法，否则性能会大大折扣，从技术角度上说，高容量缓存的算法是直接影响到硬盘性能发挥的重要因素。更大容量缓存是未来硬盘发展的必然趋势。

Ⅹ 一级Cache与二级Cache的主要区别是什么

一级Cache与二级Cache都是CPU缓存，他们的主要区别：

1、所在位置不同

一级Cache是一级缓存，位于CPU内部；

二级Cache是二级缓存，位于CPU和主存储器DRAM(Dynamic RAM)之间。

2、读取数据的顺序不同

当CPU要读取一个数据时，首先从一级缓存中查找，如果没有找到再从二级缓存中查找，如果还是没有就从三级缓存或内存中查找。一般来说，每级缓存的命中率大概都在80%左右，也就是说全部数据量的80%都可以在一级缓存中找到，只剩下20%的总数据量才需要从二级缓存、三级缓存或内存中读取，由此可见一级缓存是整个CPU缓存架构中最为重要的部分。

3、作用不同

一级缓存可分为一级指令缓存和一级数据缓存。一级指令缓存用于暂时存储并向CPU递送各类运算指令；一级数据缓存用于暂时存储并向CPU递送运算所需数据，这就是一级缓存的作用。

二级缓存是一级缓存的缓冲器：一级缓存制造成本很高因此它的容量有限，二级缓存的作用就是存储那些CPU处理时需要用到、一级缓存又无法存储的数据。