Rust 缓存双雄对决：lru-rs 与 Moka 的时空守护之旅

Rust 缓存双雄对决：lru-rs 与 Moka 的时空守护之旅

Photos provided by Unsplash OR Pexels

引言：缓存的双面镜——简单 vs. 并发，经典 vs. 现代

在 Rust 的内存管理世界中，缓存如一面双面镜：一面映照简洁高效的经典算法，另一面映射高并发的高性能引擎。lru-rs，这位“时间守护者”，以纯净的 LRU（Least Recently Used）机制守护单线程时空，受 Rust 标准库早期灵感，专注于 O(1) 操作的轻量级实现。Moka，这位“蒸汽咖啡师”，源于 Java Caffeine 的并发精华，提供线程安全、高命中率的现代缓存，支持同步/异步模式，如摩卡壶般快速萃取数据本质。

这份对比指南针对小白用户，由浅入深，从理论基础到高级实战，逐一剖析 lru-rs（https://github.com/jeromefroe/lru-rs）和 Moka（https://github.com/moka-rs/moka）的异同。我们将从安装、使用、并发、过期、性能等多角度实战对比，帮助你像品鉴双雄对决般，选择适合的缓存利器。无论你是构建 CLI 工具还是高流量服务器，这场“时空守护之旅”将让你掌握 Rust 缓存的真谛。让我们开启对比之旅，探索简单与复杂的完美平衡！

第一章：基础理论对比——LRU vs. TinyLFU，单线程 vs. 并发

1.1 LRU vs. TinyLFU：驱逐算法的哲学差异

  • lru-rs：经典 LRU 算法，使用哈希表 + 双向链表维护“最近使用”顺序。最久未用条目被驱逐，适合循环访问模式。O(1) 操作，确保常数时间，但命中率依赖访问局部性。
  • Moka：先进 TinyLFU（Tiny Least Frequently Used），结合频率和最近使用，近似最优命中率。优于 LRU，尤其在扫描式访问下。算法复杂，但提供更高效率。

对比分析：lru-rs 简单易懂，适合小规模；Moka 复杂但智能，生产中命中率可达 85%（如 crates.io 案例）。理论上，TinyLFU 在随机访问中胜出，但 lru-rs 无额外开销。

1.2 线程安全与边界控制

  • lru-rs：单线程设计，无内置并发。边界由 NonZeroUsize 容量控制，满时驱逐最旧。支持无界模式，手动管理。
  • Moka：内置线程安全，支持同步（sync 模块）和异步（future 模块）。边界包括条目数或加权大小（weigher），更灵活。

对比分析：lru-rs 轻量（小依赖树），但多线程需手动 Mutex；Moka 开箱并发，适合服务器，但依赖树较大。从表格看，Moka 在并发特性上全面领先。

1.3 其他基础差异

  • 过期策略：lru-rs 无内置；Moka 支持 TTL/TTI 和逐条目变量过期。
  • 监听器：lru-rs 无；Moka 有驱逐监听。
  • 平台支持：两者 MSRV 均为 Rust 1.70+；Moka 支持 32/64 位，但不支持 Wasm；lru-rs 更通用。

小白提示：若需简单缓存，从 lru-rs 起步；并发需求，转向 Moka。

第二章：安装与基本使用对比——从 Hello Cache 到多线程实战

2.1 安装对比

  • lru-rs：Cargo.toml 添加 lru = "0.12"。无特征，简单。
  • Moka：同步用 moka = { version = "0.12", features = ["sync"] }；异步用 “future”。需指定特征。

对比分析：lru-rs 安装零负担；Moka 灵活但需选择。

2.2 基本同步使用实战

两者都支持基本put/get。lru-rs返回引用（&V），Moka返回克隆（Option），需Arc避免昂贵克隆。

lru-rs 示例：

use lru::LruCache;
use std::num::NonZeroUsize;

fn main() {
    let mut cache = LruCache::new(NonZeroUsize::new(2).unwrap());
    cache.put("apple", 3);
    cache.put("banana", 2);
    assert_eq!(*cache.get(&"apple").unwrap(), 3);
    assert!(cache.get(&"pear").is_none());
    assert_eq!(cache.put("pear", 5), None);  // 驱逐 apple
    assert!(cache.get(&"apple").is_none());
    let v = cache.get_mut(&"banana").unwrap();
    *v = 6;
    assert_eq!(*cache.get(&"banana").unwrap(), 6);
}

Moka 示例：

use moka::sync::Cache;

fn main() {
    let cache = Cache::new(2);
    cache.insert("apple", 3);
    cache.insert("banana", 2);
    assert_eq!(cache.get(&"apple"), Some(3));
    assert_eq!(cache.get(&"pear"), None);
    cache.insert("pear", 5);  // 驱逐 apple
    assert_eq!(cache.get(&"apple"), None);
    // Moka 无 get_mut，用 get_with 或手动
}

对比分析：lru-rs 操作更直观（get_mut 就地修改）；Moka 克隆值，适合并发但需 Arc 优化。lru-rs peek 不更新顺序，Moka 无直接等价。

2.3 多线程/异步基本实战

  • lru-rs：需手动同步。
use std::sync::{Arc, Mutex};
use std::thread;
let cache = Arc::new(Mutex::new(LruCache::new(NonZeroUsize::new(10).unwrap())));
let clone = Arc::clone(&cache);
thread::spawn(move || { let mut guard = clone.lock().unwrap(); guard.put(1, 1); });
  • Moka：内置并发，克隆廉价。
use moka::sync::Cache;
use std::thread;
let cache = Cache::new(10);
let clone = cache.clone();
thread::spawn(move || { clone.insert(1, 1); });

异步 Moka（lru-rs 无内置）：

use moka::future::Cache;
#[tokio::main]
async fn main() {
    let cache = Cache::new(10);
    cache.insert(1, 1).await;
}

对比分析：lru-rs 多线程繁琐；Moka 无缝并发，异步支持 Tokio 等。lru-rs 适合单线程小白；Moka 入门稍陡但强大。

第三章：高级特性对比——过期、监听与自定义

3.1 过期策略实战

  • lru-rs：无内置，需手动定时 pop。 示例：用 tokio 定时器模拟 TTL。
use tokio::time::{sleep, Duration};
async fn manual_ttl(cache: &mut LruCache<String, String>) {
    sleep(Duration::from_secs(5)).await;
    cache.pop(&"key".to_string());
}
  • Moka：内置 TTL/TTI/变量。
use std::time::Duration;
let cache = Cache::builder().time_to_live(Duration::from_secs(5)).build();
cache.insert(1, "value");

对比分析：Moka 过期全面（缓存级 + 逐条），用分层定时轮高效；lru-rs 需自定义，简单但不优雅。从高级角度，Moka 胜出嵌入式/服务器。

3.2 监听器与自定义实战

  • lru-rs：无监听；自定义 Hasher 支持。
use rustc_hash::FxHasher;
use std::hash::BuildHasherDefault;
let hasher = BuildHasherDefault::<FxHasher>::default();
let cache = LruCache::with_hasher(NonZeroUsize::new(10).unwrap(), hasher);
  • Moka：驱逐监听、weigher 大小感知、upsert。
let cache = Cache::builder()
    .eviction_listener(|k, v, cause| { println!("Evicted {}: {}", k, v); })
    .weigher(|_k, v: &i32| *v as u32)
    .build();
cache.upsert(1, |old| old.unwrap_or(0) + 1);

对比分析：Moka 监听/upsert 原子操作高级；lru-rs 迭代器（iter_mut）支持批量，但无监听。Moka 变量过期用定时轮；lru-rs peek 高级窥探。

3.3 迭代与调整实战

  • lru-rs：支持 iter/iter_mut/into_iter，resize 动态。
cache.resize(NonZeroUsize::new(5).unwrap());
for (k, v) in cache.iter_mut() { *v += 1; }
  • Moka：并发迭代器，无 resize 直接等价，但政策调整。
for entry in cache.iter() { /* 并发安全 */ }

对比分析：lru-rs 迭代灵活；Moka 锁免费迭代，适合并发。

第四章：性能与生产实践对比——基准与真实案例

4.1 性能基准对比

用 criterion 测试（假设结果：lru-rs 单线程更快，Moka 并发胜）。

  • lru-rs：小开销，O(1) 纯净；依赖树小。
  • Moka：并发开销稍高，但 TinyLFU 高命中；v0.12 无后台线程。

实战基准：

// lru-rs
let mut cache = LruCache::new(NonZeroUsize::new(1000).unwrap());
for i in 0..1000 { cache.put(i, i); cache.get(&i); }

// Moka
let cache = Cache::new(1000);
for i in 0..1000 { cache.insert(i, i); cache.get(&i); }

分析：lru-rs 单线程吞吐高；Moka 多线程/异步优越。从表格，Moka vs. Mini Moka/Quick Cache，lru-rs 类似 Quick Cache 低开销。

4.2 生产实践对比

  • lru-rs：适合 CLI/游戏单线程，如命令历史缓存。
  • Moka：生产级，如 crates.io（85% 命中，减轻 DB）；aliyundrive-webdav（路由器元数据缓存）。

分析：lru-rs 易集成但手动并发；Moka 生产成熟，支持 32 位嵌入式。故障：Moka 32 位需禁用 atomic64；lru-rs 无此类。

第五章：选择指南——何时选谁？

  • 选 lru-rs：单线程、轻量、简单场景；小依赖、无并发需求。
  • 选 Moka：并发、异步、高命中；过期/监听/大小感知。
  • 权衡：lru-rs 小白友好；Moka 高级强大，但过杀鸡用牛刀。

小白进阶路径：从 lru-rs 学 LRU，再迁 Moka 学并发。

结语：双雄并立，守护你的 Rust 时空

通过这场由浅入深的对比，你已见证 lru-rs 的简洁守护与 Moka 的并发艺术。选择取决于你的“时空”：简单还是复杂？实践是关键——试试双库，优化你的应用。Rust 缓存之旅，继续前行！

参考资料

这份指南基于 2025 年 8 月 23 日文档版本，如有更新，请查阅最新源。Happy Caching！

版权声明：自由转载-非商用-非衍生-保持署名（创意共享3.0许可证）

Similar Posts

Rust 中的“咖啡因”：Moka 并发缓存库小白实战指南

Rust 中的“咖啡因”：Moka 并发缓存库小白实战指南

Rust 中的“时间守护者”：lru-rs LRU 缓存小白实战指南

Rust 中的“时间守护者”：lru-rs LRU 缓存小白实战指南