mirror of
https://github.com/zhwei820/learn.lianglianglee.com.git
synced 2025-09-25 04:36:41 +08:00
385 lines
26 KiB
HTML
385 lines
26 KiB
HTML
<!DOCTYPE html>
|
||
<!-- saved from url=(0046)https://kaiiiz.github.io/hexo-theme-book-demo/ -->
|
||
<html xmlns="http://www.w3.org/1999/xhtml">
|
||
<head>
|
||
<head>
|
||
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
|
||
<meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1.0, user-scalable=no">
|
||
<link rel="icon" href="/static/favicon.png">
|
||
<title>07 案例分析：无处不在的缓存，高并发系统的法宝.md.html</title>
|
||
<!-- Spectre.css framework -->
|
||
<link rel="stylesheet" href="/static/index.css">
|
||
<!-- theme css & js -->
|
||
<meta name="generator" content="Hexo 4.2.0">
|
||
</head>
|
||
<body>
|
||
<div class="book-container">
|
||
<div class="book-sidebar">
|
||
<div class="book-brand">
|
||
<a href="/">
|
||
<img src="/static/favicon.png">
|
||
<span>技术文章摘抄</span>
|
||
</a>
|
||
</div>
|
||
<div class="book-menu uncollapsible">
|
||
<ul class="uncollapsible">
|
||
<li><a href="/" class="current-tab">首页</a></li>
|
||
</ul>
|
||
<ul class="uncollapsible">
|
||
<li><a href="../">上一级</a></li>
|
||
</ul>
|
||
<ul class="uncollapsible">
|
||
<li>
|
||
<a href="/专栏/Java 性能优化实战-完/00 Java 性能优化，是进阶高级架构师的炼金石.md.html">00 Java 性能优化，是进阶高级架构师的炼金石</a>
|
||
</li>
|
||
<li>
|
||
<a href="/专栏/Java 性能优化实战-完/01 理论分析：性能优化，有哪些衡量指标？需要注意什么？.md.html">01 理论分析：性能优化，有哪些衡量指标？需要注意什么？</a>
|
||
</li>
|
||
<li>
|
||
<a href="/专栏/Java 性能优化实战-完/02 理论分析：性能优化有章可循，谈谈常用的切入点.md.html">02 理论分析：性能优化有章可循，谈谈常用的切入点</a>
|
||
</li>
|
||
<li>
|
||
<a href="/专栏/Java 性能优化实战-完/03 深入剖析：哪些资源，容易成为瓶颈？.md.html">03 深入剖析：哪些资源，容易成为瓶颈？</a>
|
||
</li>
|
||
<li>
|
||
<a href="/专栏/Java 性能优化实战-完/04 工具实践：如何获取代码性能数据？.md.html">04 工具实践：如何获取代码性能数据？</a>
|
||
</li>
|
||
<li>
|
||
<a href="/专栏/Java 性能优化实战-完/05 工具实践：基准测试 JMH，精确测量方法性能.md.html">05 工具实践：基准测试 JMH，精确测量方法性能</a>
|
||
</li>
|
||
<li>
|
||
<a href="/专栏/Java 性能优化实战-完/06 案例分析：缓冲区如何让代码加速.md.html">06 案例分析：缓冲区如何让代码加速</a>
|
||
</li>
|
||
<li>
|
||
<a class="current-tab" href="/专栏/Java 性能优化实战-完/07 案例分析：无处不在的缓存，高并发系统的法宝.md.html">07 案例分析：无处不在的缓存，高并发系统的法宝</a>
|
||
|
||
</li>
|
||
<li>
|
||
<a href="/专栏/Java 性能优化实战-完/08 案例分析：Redis 如何助力秒杀业务.md.html">08 案例分析：Redis 如何助力秒杀业务</a>
|
||
</li>
|
||
<li>
|
||
<a href="/专栏/Java 性能优化实战-完/09 案例分析：池化对象的应用场景.md.html">09 案例分析：池化对象的应用场景</a>
|
||
</li>
|
||
<li>
|
||
<a href="/专栏/Java 性能优化实战-完/10 案例分析：大对象复用的目标和注意点.md.html">10 案例分析：大对象复用的目标和注意点</a>
|
||
</li>
|
||
<li>
|
||
<a href="/专栏/Java 性能优化实战-完/11 案例分析：如何用设计模式优化性能.md.html">11 案例分析：如何用设计模式优化性能</a>
|
||
</li>
|
||
<li>
|
||
<a href="/专栏/Java 性能优化实战-完/12 案例分析：并行计算让代码“飞”起来.md.html">12 案例分析：并行计算让代码“飞”起来</a>
|
||
</li>
|
||
<li>
|
||
<a href="/专栏/Java 性能优化实战-完/13 案例分析：多线程锁的优化.md.html">13 案例分析：多线程锁的优化</a>
|
||
</li>
|
||
<li>
|
||
<a href="/专栏/Java 性能优化实战-完/14 案例分析：乐观锁和无锁.md.html">14 案例分析：乐观锁和无锁</a>
|
||
</li>
|
||
<li>
|
||
<a href="/专栏/Java 性能优化实战-完/15 案例分析：从 BIO 到 NIO，再到 AIO.md.html">15 案例分析：从 BIO 到 NIO，再到 AIO</a>
|
||
</li>
|
||
<li>
|
||
<a href="/专栏/Java 性能优化实战-完/16 案例分析：常见 Java 代码优化法则.md.html">16 案例分析：常见 Java 代码优化法则</a>
|
||
</li>
|
||
<li>
|
||
<a href="/专栏/Java 性能优化实战-完/17 高级进阶：JVM 如何完成垃圾回收？.md.html">17 高级进阶：JVM 如何完成垃圾回收？</a>
|
||
</li>
|
||
<li>
|
||
<a href="/专栏/Java 性能优化实战-完/18 高级进阶：JIT 如何影响 JVM 的性能？.md.html">18 高级进阶：JIT 如何影响 JVM 的性能？</a>
|
||
</li>
|
||
<li>
|
||
<a href="/专栏/Java 性能优化实战-完/19 高级进阶：JVM 常见优化参数.md.html">19 高级进阶：JVM 常见优化参数</a>
|
||
</li>
|
||
<li>
|
||
<a href="/专栏/Java 性能优化实战-完/20 SpringBoot 服务性能优化.md.html">20 SpringBoot 服务性能优化</a>
|
||
</li>
|
||
<li>
|
||
<a href="/专栏/Java 性能优化实战-完/21 性能优化的过程方法与求职面经总结.md.html">21 性能优化的过程方法与求职面经总结</a>
|
||
</li>
|
||
<li>
|
||
<a href="/专栏/Java 性能优化实战-完/22 结束语 实践出真知.md.html">22 结束语 实践出真知</a>
|
||
</li>
|
||
</ul>
|
||
</div>
|
||
</div>
|
||
<div class="sidebar-toggle" onclick="sidebar_toggle()" onmouseover="add_inner()" onmouseleave="remove_inner()">
|
||
<div class="sidebar-toggle-inner"></div>
|
||
</div>
|
||
<script>
|
||
function add_inner() {
|
||
let inner = document.querySelector('.sidebar-toggle-inner')
|
||
inner.classList.add('show')
|
||
}
|
||
function remove_inner() {
|
||
let inner = document.querySelector('.sidebar-toggle-inner')
|
||
inner.classList.remove('show')
|
||
}
|
||
function sidebar_toggle() {
|
||
let sidebar_toggle = document.querySelector('.sidebar-toggle')
|
||
let sidebar = document.querySelector('.book-sidebar')
|
||
let content = document.querySelector('.off-canvas-content')
|
||
if (sidebar_toggle.classList.contains('extend')) { // show
|
||
sidebar_toggle.classList.remove('extend')
|
||
sidebar.classList.remove('hide')
|
||
content.classList.remove('extend')
|
||
} else { // hide
|
||
sidebar_toggle.classList.add('extend')
|
||
sidebar.classList.add('hide')
|
||
content.classList.add('extend')
|
||
}
|
||
}
|
||
function open_sidebar() {
|
||
let sidebar = document.querySelector('.book-sidebar')
|
||
let overlay = document.querySelector('.off-canvas-overlay')
|
||
sidebar.classList.add('show')
|
||
overlay.classList.add('show')
|
||
}
|
||
function hide_canvas() {
|
||
let sidebar = document.querySelector('.book-sidebar')
|
||
let overlay = document.querySelector('.off-canvas-overlay')
|
||
sidebar.classList.remove('show')
|
||
overlay.classList.remove('show')
|
||
}
|
||
</script>
|
||
<div class="off-canvas-content">
|
||
<div class="columns">
|
||
<div class="column col-12 col-lg-12">
|
||
<div class="book-navbar">
|
||
<!-- For Responsive Layout -->
|
||
<header class="navbar">
|
||
<section class="navbar-section">
|
||
<a onclick="open_sidebar()">
|
||
<i class="icon icon-menu"></i>
|
||
</a>
|
||
</section>
|
||
</header>
|
||
</div>
|
||
<div class="book-content" style="max-width: 960px; margin: 0 auto;
|
||
overflow-x: auto;
|
||
overflow-y: hidden;">
|
||
<div class="book-post">
|
||
<p id="tip" align="center"></p>
|
||
<div><h1>07 案例分析：无处不在的缓存，高并发系统的法宝</h1>
|
||
<p>在上一课时，我们介绍了“缓冲”，这一课时我将介绍“缓冲”的孪生兄弟“缓存”。</p>
|
||
<p>和缓冲类似，缓存可能是软件中使用最多的优化技术了，比如：在最核心的 CPU 中，就存在着多级缓存；为了消除内存和存储之间的差异，各种类似 Redis 的缓存框架更是层出不穷。</p>
|
||
<p>缓存的优化效果是非常好的，它既可以让原本载入非常缓慢的页面，瞬间秒开，也能让本是压力山大的数据库，瞬间清闲下来。</p>
|
||
<p><strong>缓存</strong>，<strong>本质</strong>上是为了协调两个速度差异非常大的组件，如下图所示，通过加入一个中间层，将常用的数据存放在相对高速的设备中。</p>
|
||
<p><img src="assets/CgqCHl8nuCKAad7oAAAk6v90xvo900.png" alt="png" /></p>
|
||
<p>在我们平常的应用开发中，根据缓存所处的物理位置，一般分为<strong>进程内</strong>缓存和<strong>进程外</strong>缓存。</p>
|
||
<p>本课时我们主要聚焦在进程内缓存上，在 Java 中，进程内缓存，就是我们常说的堆内缓存。Spring 的默认实现里，就包含 Ehcache、JCache、Caffeine、Guava Cache 等。</p>
|
||
<h3>Guava 的 LoadingCache</h3>
|
||
<p>Guava 是一个常用的工具包，其中的 <strong>LoadingCache</strong>（下面简称 LC），是非常好用的<strong>堆内缓存工具</strong>。通过学习 LC 的结构，即可了解堆内缓存设计的一般思路。</p>
|
||
<p>缓存一般是比较昂贵的组件，容量是有限制的，设置得过小，或者过大，都会影响缓存性能：</p>
|
||
<ul>
|
||
<li>缓存空间过小，就会造成高命中率的元素被频繁移出，失去了缓存的意义；</li>
|
||
<li>缓存空间过大，不仅浪费宝贵的缓存资源，还会对垃圾回收产生一定的压力。</li>
|
||
</ul>
|
||
<p>通过 Maven，即可引入 guava 的 jar 包：</p>
|
||
<pre><code><dependency>
|
||
<groupId>com.google.guava</groupId>
|
||
<artifactId>guava</artifactId>
|
||
<version>29.0-jre</version>
|
||
</dependency>
|
||
</code></pre>
|
||
<p>下面介绍一下 LC 的常用操作：</p>
|
||
<p><img src="assets/Ciqc1F8nuDmAJcstAABnG73x05M360.png" alt="png" /></p>
|
||
<h4>1.缓存初始化</h4>
|
||
<p>首先，我们可以通过下面的参数设置一下 LC 的大小。一般，我们只需给缓存提供一个上限。</p>
|
||
<ul>
|
||
<li><strong>maximumSize</strong> 这个参数用来设置缓存池的最大容量，达到此容量将会清理其他元素；</li>
|
||
<li><strong>initialCapacity</strong> 默认值是 16，表示初始化大小；</li>
|
||
<li><strong>concurrencyLevel</strong> 默认值是 4，和初始化大小配合使用，表示会将缓存的内存划分成 4 个 segment，用来支持高并发的存取。</li>
|
||
</ul>
|
||
<h4>2.缓存操作</h4>
|
||
<p>那么缓存数据是怎么放进去的呢？有两种模式：</p>
|
||
<ul>
|
||
<li>使用 put 方法手动处理，比如，我从数据库里查询出一个 User 对象，然后手动调用代码进去；</li>
|
||
<li>主动触发（ 这也是 Loading 这个词的由来），通过提供一个 CacheLoader 的实现，就可以在用到这个对象的时候，进行延迟加载。</li>
|
||
</ul>
|
||
<pre><code>public static void main(String[] args) {
|
||
LoadingCache<String, String> lc = CacheBuilder
|
||
.newBuilder()
|
||
.build(new CacheLoader<String, String>() {
|
||
@Override
|
||
public String load(String key) throws Exception {
|
||
return slowMethod(key);
|
||
}
|
||
});
|
||
}
|
||
static String slowMethod(String key) throws Exception {
|
||
Thread.sleep(1000);
|
||
return key + ".result";
|
||
}
|
||
</code></pre>
|
||
<p>上面是主动触发的示例代码，你可以使用 <strong>get</strong> 方法<strong>获取</strong>缓存的值。比如，当我们执行 lc.get("a") 时，第一次会比较缓慢，因为它需要到数据源进行获取；第二次就瞬间返回了，也就是缓存命中了。具体时序可以参见下面这张图。</p>
|
||
<p><img src="assets/CgqCHl8nuFGACX8vAABYHt8o1wc201.png" alt="png" /></p>
|
||
<p>除了靠 LC 自带的回收策略，我们也可以<strong>手动删除</strong>某一个元素，这就是 <strong>invalidate</strong> 方法。当然，数据的这些删除操作，也是可以监听到的，只需要设置一个监听器就可以了，代码如下：</p>
|
||
<pre><code>.removalListener(notification -> System.out.println(notification))
|
||
</code></pre>
|
||
<h4>3.回收策略</h4>
|
||
<p>缓存的大小是有限的，满了以后怎么办？这就需要回收策略进行处理，接下来我会向你介绍三种回收策略。</p>
|
||
<p>（1）第一种回收策略<strong>基于容量</strong></p>
|
||
<p>这个比较好理解，也就是说如果缓存满了，就会按照 LRU 算法来移除其他元素。</p>
|
||
<p>（2）第二种回收策略<strong>基于时间</strong></p>
|
||
<ul>
|
||
<li>一种方式是，通过 expireAfterWrite 方法设置数据写入以后在某个时间失效；</li>
|
||
<li>另一种是，通过 expireAfterAccess 方法设置最早访问的元素，并优先将其删除。</li>
|
||
</ul>
|
||
<p>（3）第三种回收策略<strong>基于 JVM 的垃圾回收</strong></p>
|
||
<p>我们都知道对象的引用有强、软、弱、虚等四个级别，通过 weakKeys 等函数即可设置相应的引用级别。当 JVM 垃圾回收的时候，会主动清理这些数据。</p>
|
||
<p>关于第三种回收策略，有一个<strong>高频面试题：如果你同时设置了 weakKeys 和 weakValues函数，LC 会有什么反应？</strong></p>
|
||
<p>答案：如果同时设置了这两个函数，它代表的意思是，当没有任何强引用，与 key <strong>或者</strong> value 有关系时，就删掉整个缓存项。这两个函数经常被误解。</p>
|
||
<h4>4.缓存造成内存故障</h4>
|
||
<p>LC 可以通过 recordStats 函数，对缓存加载和命中率等情况进行监控。</p>
|
||
<p><strong>值得注意的是：LC 是基于数据条数而不是基于缓存物理大小的，所以如果你缓存的对象特别大，就会造成不可预料的内存占用。</strong></p>
|
||
<p>围绕这点，我分享一个由于不正确使用缓存导致的常见内存故障。</p>
|
||
<p>大多数堆内缓存，都会将对象的引用设置成弱引用或软引用，这样内存不足时，可以优先释放缓存占用的空间，给其他对象腾出地方。这种做法的初衷是好的，但容易出现问题。</p>
|
||
<p>当你的缓存使用非常频繁，数据量又比较大的情况下，缓存会占用大量内存，如果此时发生了垃圾回收（GC），缓存空间会被释放掉，但又被迅速占满，从而会再次触发垃圾回收。如此往返，GC 线程会耗费大量的 CPU 资源，缓存也就失去了它的意义。</p>
|
||
<p>所以在这种情况下，把缓存设置的小一些，减轻 JVM 的负担，是一个很好的方法。</p>
|
||
<h3>缓存算法</h3>
|
||
<h4>1.算法介绍</h4>
|
||
<p>堆内缓存最常用的有 FIFO、LRU、LFU 这三种算法。</p>
|
||
<ul>
|
||
<li><strong>FIFO</strong></li>
|
||
</ul>
|
||
<p>这是一种先进先出的模式。如果缓存容量满了，将会<strong>移除最先加入的元素</strong>。这种缓存实现方式简单，但符合先进先出的队列模式场景的功能不多，应用场景较少。</p>
|
||
<ul>
|
||
<li><strong>LRU</strong></li>
|
||
</ul>
|
||
<p>LRU 是最近最少使用的意思，当缓存容量达到上限，它会<strong>优先移除那些最久未被使用的数据</strong>，LRU是目前<strong>最常用</strong>的缓存算法，稍后我们会使用 Java 的 API 简单实现一个。</p>
|
||
<ul>
|
||
<li><strong>LFU</strong></li>
|
||
</ul>
|
||
<p>LFU 是最近最不常用的意思。相对于 LRU 的时间维度，LFU 增加了访问次数的维度。如果缓存满的时候，将<strong>优先移除访问次数最少的元素</strong>；而当有多个访问次数相同的元素时，则<strong>优先移除最久未被使用的元素</strong>。</p>
|
||
<h4>2.实现一个 LRU 算法</h4>
|
||
<p>Java 里面实现 LRU 算法可以有多种方式，其中最常用的就是 <strong>LinkedHashMap，这也是一个需要你注意的面试高频考点</strong>。</p>
|
||
<p>首先，我们来看一下 LinkedHashMap 的构造方法：</p>
|
||
<pre><code>public LinkedHashMap(int initialCapacity,
|
||
float loadFactor,
|
||
boolean accessOrder)
|
||
</code></pre>
|
||
<p>accessOrder 参数是实现 LRU 的关键。当 accessOrder 的值为 true 时，将按照对象的访问顺序排序；当 accessOrder 的值为 false 时，将按照对象的插入顺序排序。我们上面提到过，按照访问顺序排序，其实就是 LRU。</p>
|
||
<p><img src="assets/CgqCHl8nuJeAQCW4AABgBDKI74g880.png" alt="png" /></p>
|
||
<p>如上图，按照缓存的一般设计方式，和 LC 类似，当你向 LinkedHashMap 中添加新对象的时候，就会调用 removeEldestEntry 方法。这个方法默认返回 false，表示永不过期。我们只需要覆盖这个方法，当超出容量的时候返回 true，触发移除动作就可以了。关键代码如下：</p>
|
||
<pre><code>public class LRU extends LinkedHashMap {
|
||
int capacity;
|
||
public LRU(int capacity) {
|
||
super(16, 0.75f, true);
|
||
this.capacity = capacity;
|
||
}
|
||
@Override
|
||
protected boolean removeEldestEntry(Map.Entry eldest) {
|
||
return size() > capacity;
|
||
}
|
||
}
|
||
</code></pre>
|
||
<p>相比较 LC，这段代码实现的功能是比较简陋的，它甚至不是线程安全的，但它体现了缓存设计的一般思路，是 Java 中最简单的 LRU 实现方式。</p>
|
||
<h3>进一步加速</h3>
|
||
<p>在 Linux 系统中，通过 free 命令，能够看到系统内存的使用状态。其中，有一块叫作 <strong>cached</strong> 的区域，占用了大量的内存空间。</p>
|
||
<p><img src="assets/Ciqc1F8nuKqAJaGZAAF4FboRD9E367.png" alt="png" /></p>
|
||
<p>如图所示，这个区域，其实就是存放了操作系统的文件缓存，当应用再次用到它的时候，就不用再到磁盘里走一圈，能够从内存里快速载入。</p>
|
||
<p>在文件读取的缓存方面，操作系统做得更多。由于磁盘擅长顺序读写，在随机读写的时候，效率很低，所以，操作系统使用了智能的<strong>预读算法</strong>（readahead），将数据从硬盘中加载到缓存中。</p>
|
||
<p>预读算法有三个关键点：</p>
|
||
<ul>
|
||
<li><strong>预测性</strong>，能够根据应用的使用数据，提前预测应用后续的操作目标；</li>
|
||
<li><strong>提前</strong>，能够将这些数据提前加载到缓存中，保证命中率；</li>
|
||
<li><strong>批量</strong>，将小块的、频繁的读取操作，合并成顺序的批量读取，提高性能。</li>
|
||
</ul>
|
||
<p>预读技术一般都是比较智能的，能够覆盖大多数后续的读取操作。举个极端的例子，如果我们的数据集合比较小，访问频率又非常高，就可以使用完全载入的方式，来替换懒加载的方式。在系统启动的时候，将数据加载到缓存中。</p>
|
||
<h3>缓存优化的一般思路</h3>
|
||
<p>一般，缓存针对的主要是读操作。<strong>当你的功能遇到下面的场景时</strong>，就可以选择使用缓存组件进行性能优化：</p>
|
||
<ul>
|
||
<li>存在数据热点，缓存的数据能够被频繁使用；</li>
|
||
<li>读操作明显比写操作要多；</li>
|
||
<li>下游功能存在着比较悬殊的性能差异，下游服务能力有限；</li>
|
||
<li>加入缓存以后，不会影响程序的正确性，或者引入不可预料的复杂性。</li>
|
||
</ul>
|
||
<p>缓存组件和缓冲类似，也是在两个组件速度严重不匹配的时候，引入的一个中间层，但<strong>它们服务的目标是不同的：</strong></p>
|
||
<ul>
|
||
<li>缓冲，数据一般只使用一次，等待缓冲区满了，就执行 flush 操作；</li>
|
||
<li>缓存，数据被载入之后，可以多次使用，数据将会共享多次。</li>
|
||
</ul>
|
||
<p><strong>缓存最重要的指标就是命中率</strong>，有以下几个因素会影响命中率。</p>
|
||
<p><strong>（1）缓存容量</strong></p>
|
||
<p>缓存的容量总是有限制的，所以就存在一些冷数据的逐出问题。但缓存也不是越大越好，它不能明显挤占业务的内存。</p>
|
||
<p><strong>（2）数据集类型</strong></p>
|
||
<p>如果缓存的数据是非热点数据，或者是操作几次就不再使用的冷数据，那命中率肯定会低，缓存也会失去了它的作用。</p>
|
||
<p><strong>（3）缓存失效策略</strong></p>
|
||
<p>缓存算法也会影响命中率和性能，目前效率最高的算法是 Caffeine 使用的 <strong>W-TinyLFU 算法</strong>，它的命中率非常高，内存占用也更小。新版本的 spring-cache，已经默认支持 Caffeine。</p>
|
||
<p>下图展示了这个算法的性能，<a href="https://github.com/ben-manes/caffeine">从官网的 github 仓库</a>就可以找到 JMH 的测试代码。</p>
|
||
<p><img src="assets/CgqCHl8nuQWAKsjIAAG1hzHS76Q255.png" alt="png" /></p>
|
||
<p>推荐使用 Guava Cache 或者 Caffeine 作为堆内缓存解决方案，然后通过它们提供的一系列监控指标，来调整缓存的大小和内容，一般来说：</p>
|
||
<ul>
|
||
<li>缓存命中率达到 50% 以上，作用就开始变得显著；</li>
|
||
<li>缓存命中率低于 10%，那就需要考虑缓存组件的必要性了。</li>
|
||
</ul>
|
||
<p>引入缓存组件，能够显著提升系统性能，但也会引入新的问题。其中，最典型的也是面试高频问题：如何保证缓存与源数据的同步？关于这点，我们会在下一课时进行讲解。</p>
|
||
<h3>小结</h3>
|
||
<p>最后，我来总结一下本课时的知识要点。</p>
|
||
<p>我们先以 Guava 的 LoadingCache 为例，讲解了堆内缓存设计的一些思路；同时，介绍了一个因为缓存不合理利用所造成的内存故障，这些都是面试中的高频问题；然后又讲解了，三个常用的缓存算法 LRU、LFU、FIFO，并以 LinkedHashMap 为基础，实现了一个最简单的 LRU 缓存。</p>
|
||
<p>本课时还提到了使用预读或者提前载入等方式，来进一步加速应用的方法，readahead技术，在操作系统、数据库中使用非常多，性能提升也比较显著。</p>
|
||
<p>最后，我们提到可以通过利用缓存框架的一些监控数据，来调整缓存的命中率，要达到50% 的命中率才算有较好的效果。</p>
|
||
<p>接下来，我再简单举两个<strong>缓存应用</strong>的例子。</p>
|
||
<ul>
|
||
<li>第一个是 HTTP 304 状态码，它是 Not Modified 的意思。
|
||
浏览器客户端会发送一个条件性的请求，服务端可以通过 If-Modified-Since 头信息判断缓冲的文件是否是最新的。如果是，那么客户端就直接使用缓存，不用进行再读取了。</li>
|
||
<li>另一个是关于 CDN，这是一种变相的缓存。
|
||
用户会从离它最近最快的节点，读取文件内容。如果这个节点没有缓存这个文件，那么 CDN 节点就会从源站拉取一份，下次有相同的读取请求时，就可以快速返回。</li>
|
||
</ul>
|
||
<p>缓存的应用非常广泛，大家在平常的工作中，也可以尝试进行总结、类比。</p>
|
||
</div>
|
||
</div>
|
||
<div>
|
||
<div style="float: left">
|
||
<a href="/专栏/Java 性能优化实战-完/06 案例分析：缓冲区如何让代码加速.md.html">上一页</a>
|
||
</div>
|
||
<div style="float: right">
|
||
<a href="/专栏/Java 性能优化实战-完/08 案例分析：Redis 如何助力秒杀业务.md.html">下一页</a>
|
||
</div>
|
||
</div>
|
||
</div>
|
||
</div>
|
||
</div>
|
||
</div>
|
||
<a class="off-canvas-overlay" onclick="hide_canvas()"></a>
|
||
</div>
|
||
<script defer src="https://static.cloudflareinsights.com/beacon.min.js/v652eace1692a40cfa3763df669d7439c1639079717194" integrity="sha512-Gi7xpJR8tSkrpF7aordPZQlW2DLtzUlZcumS8dMQjwDHEnw9I7ZLyiOj/6tZStRBGtGgN6ceN6cMH8z7etPGlw==" data-cf-beacon='{"rayId":"7099712e8f7a3d60","version":"2021.12.0","r":1,"token":"1f5d475227ce4f0089a7cff1ab17c0f5","si":100}' crossorigin="anonymous"></script>
|
||
</body>
|
||
<!-- Global site tag (gtag.js) - Google Analytics -->
|
||
<script async src="https://www.googletagmanager.com/gtag/js?id=G-NPSEEVD756"></script>
|
||
<script>
|
||
window.dataLayer = window.dataLayer || [];
|
||
function gtag() {
|
||
dataLayer.push(arguments);
|
||
}
|
||
gtag('js', new Date());
|
||
gtag('config', 'G-NPSEEVD756');
|
||
var path = window.location.pathname
|
||
var cookie = getCookie("lastPath");
|
||
console.log(path)
|
||
if (path.replace("/", "") === "") {
|
||
if (cookie.replace("/", "") !== "") {
|
||
console.log(cookie)
|
||
document.getElementById("tip").innerHTML = "<a href='" + cookie + "'>跳转到上次进度</a>"
|
||
}
|
||
} else {
|
||
setCookie("lastPath", path)
|
||
}
|
||
function setCookie(cname, cvalue) {
|
||
var d = new Date();
|
||
d.setTime(d.getTime() + (180 * 24 * 60 * 60 * 1000));
|
||
var expires = "expires=" + d.toGMTString();
|
||
document.cookie = cname + "=" + cvalue + "; " + expires + ";path = /";
|
||
}
|
||
function getCookie(cname) {
|
||
var name = cname + "=";
|
||
var ca = document.cookie.split(';');
|
||
for (var i = 0; i < ca.length; i++) {
|
||
var c = ca[i].trim();
|
||
if (c.indexOf(name) === 0) return c.substring(name.length, c.length);
|
||
}
|
||
return "";
|
||
}
|
||
</script>
|
||
</html>
|