对于互联网业务来说，传统的直接访问数据库方式，主要通过数据分片、一主多从等方式来扛住读写流量，但随着数据量的积累和流量的激增，仅依赖数据库来承接所有流量，不仅成本高、效率低、而且还伴随着稳定性降低的风险。
鉴于大部分业务通常是读多写少（读取频率远远高于更新频率），甚至存在读操作数量高出写操作多个数量级的情况。因此， 在架构设计中，常采用增加缓存层来提高系统的响应能力 ，提升数据读写性能、减少数据库访问压力，从而提升业务的稳定性和访问体验。
根据 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”的方案。
❷ SpringCache优化、缓存一致性、多级缓存
先记录一些纲要
1、SpringCache是写库之后更新的策略，对缓存一致性的不太友好
2、继承RedisCacheManager重写createRedisCache，继承RedisCache重写put
3、缓存一致性有两个方案，一个是先写库再删除缓存、第二个是先删除缓存再写库。
先写库再删除缓存配合超时时间一般没啥问题，极端的情况遇到缓存失效，线程读库和加缓存之间，完成了一次写库和删缓存的操作，导致加的缓存是旧的。总结就是读中加入了一次写。A读库 B写库 B删缓存 A加缓存。
先删缓存再写库的话，是写中加入了一次读。A删缓存 B读库 B加缓存 A写库A。这个概率比上面的大。
这两种方案的问题的解决方式是一样的，就是延时双删策略。即：
删缓存 写库 延时再次删除缓存（需超过一次读库的时间，可以新启线程完成）
或者 写库 删缓存 延时再次删除缓存（需超过一次读库的时间，可以新启线程完成）
如果有主从读写分离，需要将延时再加上主从同步的时间。
还有个第二次删除失败的问题，这个问题可以通过消息中间件，反复尝试进行。或者通过订阅binlog，反复进行。
多级缓存可以参考阿里开源的JetCache的实现
后面会给出demo和源码解析。
❸ 浏览器缓存机制简单概括和分析
对于访问的页面和请求，为了缩短网页请求资源的距离，减少延迟，并且由于缓存文件可以重复利用，还可以减少带宽，降低网络负荷，浏览器和服务器都有可能会对请求资源进行缓存，接下来的文章就简单介绍和分析浏览器的缓存机制。
深入理解浏览器的缓存机制： https://www.jianshu.com/p/54cc04190252
这篇文章已经有详细的讲解，这里就概括一下：
以首页的请求为例：
1、强制缓存策略(Expires和Cache-Control) ：当浏览器发起http请求的时候，如果配置了缓存策略且缓存在有效期内，会直接使用浏览器缓存。 不使用强制缓存 （ Cache-Control=no-chache， 或者 max-age=0 ）
（1）、图中请求服务器：是 max-age=0 的情况，浏览器直接请求服务器资源，而不是用本地缓存
（2）、图中磁盘缓存和内存缓存：就是浏览器使用了本地缓存而不再请求服务器资源
2、协商缓存策略（Last-Modified和If-Modified-Since， ETag和If-None-Match）： 当浏览器发起http请求的时候，如果 强制缓存策略 失效，或者者禁用了强制缓存，这时候会根据 If-Modified-Since 中的值与服务器中这个资源的最后修改时间对比，如果没有变化，返回304和空的响应体，直接从缓存读取，如果If-Modified-Since的时间小于服务器中这个资源的最后修改时间，说明文件有更新，于是返回新的资源文件和200。
不使用协商缓存 （ Cache-Control=no-store ），这个参数同时也会 禁用强制缓存。
（1）、服务器资源返回无更新，浏览器使用上次请求的资源
（2）、服务器资源有更新，返回200并返回最新的资源
3、不使用缓存策略（Cache-Control=no-store）： 所有内容都不会被缓存，即不使用强制缓存，也不使用协商缓存。当response head 设置了no-store，浏览器不会对返回的资源做缓存，每次请求都是直接请求服务器。这可以保证浏览器每次都能拿最新的资源，即使资源对比上次请求没有任何更新，但同时也降低了页面的响应速度，和增加了网络的IO与服务器的压力。
可以明显的看到请求时间，请求服务器资源时间 >> 请求磁盘缓存 > 请求内存缓存，所以合适的缓存策略，可以在不影响业务的情况下，极大地提升客户体验和后台服务器压力。
❹ 苹果手机缓存慢
手机永久了，大量的垃圾文件导致手机越来越卡，iPhone也会有这种情况。那么苹果手机卡顿反应慢怎么办？如果手机非常卡顿的话不妨试试下面9招会让iPhone运行速度提升不少
苹果手机卡顿反应慢怎么办?
1、清空Safari缓存
经常使用 Safari 浏览网页时间久了会产生大量缓存数据，需要清空Safari的缓存来保持它的运行流畅。想要执行这个操作，需要进入【设置】-【Safari】，然后点击“清除历史记录”和“清除Cookies和数据”。
iPhone手机变卡变慢
2、关闭自动更新自动下载
如果iPhone在使用时出现卡顿，那可能是因为它正在后台尝试应用升级，而这完全可以通过手动的方式执行。想要更改自动升级应用的设置，你需要进入【设置】-【iTunes Store和App Store】自动下载的项目，然后全部关闭。
运行飞速起来的方法
3、删除旧的无用照片和视频
删除不必要的文件是加速手机运行速度的主要方式之一。如果iPhone当中存储了几百上千张照片以及很多的视频，可以将它们备份到电脑或是iCloud，然后在手机当中删除。毕竟手机内存空间有限，对于收藏照片来说，手机真不是一个好的地方。
删除旧的无用照片和视频
4、删除占用大量空间的应用
iPhone越是臃肿，运行速度也就越慢。可以在设置-通用-用量当中查看到每款应用的空间占用，然后将那些占用空间大但并不是必要的应用删除。大量“僵尸”应用存在于手机上，只会拖累手机的运行速度，与其让它放着占用大量空间还不如删了。
删除占用大量空间的应用
5、删除旧的短信会话
大量的短信也是拖垮手机速度的原因之一，有时短信多了，打开信息应用时要卡一下等待一会才能进入。如果搞不清楚手机为什么变卡，可以尝试删除手机当中那些无意义的垃圾短信。
删除旧的短信会话
6、关闭后台不必要运行的应用
频繁的关闭“后台”只会加快iPhone的耗电速度，但是对于一些平时不怎么用的应用，完全可以双击home键关闭它，只保留常用的即可。像定位导航和音乐类应用是常驻内存的，没用时最好关了。
关闭后台不必要运行的应用
7、能手动执行的操作就不要开启自动模式
iPhone会经常询问是否要加入附近的Wi-Fi网络吗?如果是，或许应该关掉这个功能。因为当iPhone在进行任何自动操作时，比如搜索附近Wi-Fi或升级应用，都会降低运行速度。想要关闭该功能，需要进入【设置】-【无线局域网】-【询问是否加入网络】，然后将其关闭。
能手动执行的操作就不要开启自动模式
8、定期重启手机
在使用iPhone时，大多数用户都会一直保持着开机状态，但定期重启手机其实是很有必要的。关闭手机可以帮助iPhone摆脱那些一直在占用系统资源的东西。
9、升级恢复系统
终极解决办法：刷机恢复系统，让系统恢复到刚出厂的状态。如果越狱也不知道干嘛还有就是不是非常必要建议还是别越狱了，越狱后安装些插件手机会卡很多。
以上就是让手机恢复神速的几个小妙招啦，希望能对大家有帮助！
❺ 先删后写为何不能用延迟双删
先删后写会出现一致性的问题
在这里，我们讨论三种更新策略：
先更新缓存，再更新数据库
先更新数据库，再更新缓存
先删除缓存，再更新数据库
先更新数据库，再删除缓存
- public void write(String key,Object data){
- redis.delKey(key);
- db.updateData(data);
- Thread.sleep(1000);
- redis.delKey(key);
- }
先删缓存，将更新数据库的操作放进有序队列中
从缓存查不到的查询操作，都进入有序队列
读请求积压，大量超时，导致数据库的压力：限流、熔断
如何避免大量请求积压：将队列水平拆分，提高并行度。
保证相同请求路由正确。
第一种，先更新缓存，再更新数据库
问题：更新缓存成功，更新数据库失败，导致数据不一致。
第二种，先更新数据库，再更新缓存
问题：
1、A更新数据库
2、B更新数据库
3、B写入缓存
4、A写入缓存
出现数据不一致。
考虑另一种情况， 有如下两点：
（1）如果你是一个写数据库场景比较多，而读数据场景比较少的业务需求，采用这种方案就会导致，数据压根还没读到，缓存就被频繁的更新，浪费性能。
（2）如果你写入数据库的值，并不是直接写入缓存的，而是要经过一系列复杂的计算再写入缓存。那么，每次写入数据库后，都再次计算写入缓存的值，无疑是浪费性能的。显然，删除缓存更为适合。
第三种，先删除缓存，再更新数据库。
问题：
1、A删除缓存
2、B查询数据库获取旧值
3、B更新了缓存
4、A更新数据库
出现数据不一致的问题
延时双删
问题一：延时双删，演变成了：先更新数据库，再删除缓存。。。。
比如：
1、A删除缓存
2、B查询数据库获取旧值
3、B更新了缓存
4、A更新数据库
5、A延时删缓存
1～3步执行后，数据库和缓存是一致的，相当于没删除。
4～5步：先更新数据库，再删缓存。
所以延时双删演变成了：先更新数据库，再删除缓存。问题还是没解决。。。
为什么？假设，此时，在第4步执行之前，又来了个查询C，C查询到旧值。第6步：C将旧值插入缓存。此时出现缓存和数据库不一致。
延时并不能解决：C插入缓存的操作在第5步后面执行，比如C遇到网络问题、GC问题等。当然这是小概率，但并不代表不存在。
当然，延时越长，这个问题越能规避。如果业务需求不是非常严格，是可以忽略的。
问题二：吞吐量
问题三：数据库更新后，无法保证下一次查询，从缓存获取的值和数据库是一致的。
第四种，先更新数据库，再删除缓存
问题：上面C的查询，已经说明问题了。
出现数据不一致的概率，比较小。采取这个方案，取决于业务需求。
终极方案
请求串行化
真正靠谱的方案：将访问操作串行化
需要解决的问题：
❻ JAVA几种缓存技术介绍说明
1、TreeCache / JBossCache
JBossCache是一个复制的事务处理缓存，它允许你缓存企业级应用数据来更好的改善性能。缓存数据被自动复制，让你轻松进行JBoss服务器之间 的集群工作。JBossCache能够通过JBoss应用服务或其他J2EE容器来运行一个MBean服务，当然，它也能独立运行。
2、WhirlyCache
Whirlycache是一个快速的、可配置的、存在于内存中的对象的缓存。它能够通过缓存对象来加快网站或应用程序的速度，否则就必须通过查询数据库或其他代价较高的处理程序来建立。
3、SwarmCache
SwarmCache是一个简单且有效的分布式缓存，它使用IP multicast与同一个局域网的其他主机进行通讯，是特别为集群和数据驱动web应用程序而设计的。SwarmCache能够让典型的读操作大大超过写操作的这类应用提供更好的性能支持。
4、JCache
JCache是个开源程序，正在努力成为JSR-107开源规范，JSR-107规范已经很多年没改变了。这个版本仍然是构建在最初的功能定义上。
5、ShiftOne
ShiftOne Java Object Cache是一个执行一系列严格的对象缓存策略的Java lib，就像一个轻量级的配置缓存工作状态的框架。