2.4 DashMap 深度应用：高性能并发容器的正确使用姿势，性能优化技巧
·
DashMap 深度应用：高性能并发容器的正确使用姿势，性能优化技巧
引言：超越我们自制的 ConcurrentHashMap
在上一章，我们亲手构建了一个分片式的并发哈希表。这个过程让我们深入理解了并发数据结构的设计原理，特别是细粒度锁的核心思想。然而，我们自制的版本还比较初级，缺少很多关键功能，比如高效的迭代器、动态扩容和更复杂的原子 API。
在生产环境中，我们通常不会“重新发明轮子”，而是选择社区中经过千锤百炼的优秀库。dashmap 就是 Rust 生态中最流行、性能最高的高性能并发哈希表的实现。它在内部采用了与我们类似的分片思想，但进行了大量优化，提供了更丰富、更符合人体工程学的 API。
本章将带你深入 dashmap 的世界，学习它的正确使用姿势，探索其高级功能和性能优化技巧，并将其与我们自制的版本以及 std::sync::RwLock<HashMap> 进行对比。
认识 DashMap
DashMap 是一个为高并发场景优化的哈希表。它的名字来源于其作者 “Acrimon” 的另一个项目 “sled”，sled 是一种嵌入式数据库，而狗拉雪橇（dog sled）的队伍（dash）给了他灵感，DashMap 就像一群协同工作的哈士奇，每个都独立拉动一部分负载。
DashMap 的核心特性
- 极高的并发性能：内部同样采用分片（sharding）技术，将锁的粒度降到最低。
- API 设计友好：提供了与标准
HashMap类似的 API，学习成本低。 - 直接访问，无需
lock()：dashmap将锁的细节隐藏在了内部，你不需要像使用RwLock<HashMap>那样显式调用.read()或.write()。这使得代码更简洁。 - 动态扩容：当哈希表变得拥挤时，
DashMap可以在不阻塞整个表的情况下进行动态扩容。 - 分片级别的原子操作：提供了类似
HashMap的entryAPI，但操作是并发安全的。
添加依赖
首先，在你的 Cargo.toml 中添加 dashmap：
[dependencies]
dashmap = "5.4" # 建议使用最新版本
DashMap 基础用法
DashMap 的 API 被设计得与 std::collections::HashMap 非常相似，上手非常容易。
创建、插入和获取
use dashmap::DashMap;
use std::sync::Arc;
use std::thread;
fn main() {
// 创建一个 DashMap
let map = DashMap::new();
// 插入数据，就像使用 HashMap 一样，无需显式锁定
map.insert("key1", "value1");
map.insert("key2", "value2");
// 获取数据，返回的是一个 Ref<'_, K, V>
// 这类似于一个读锁守卫（Read Lock Guard）
if let Some(value) = map.get("key1") {
// value 是一个智能指针，解引用后可以得到值的引用
assert_eq!(*value, "value1");
println!("Found value: {}", *value);
}
// 当 value 离开作用域时，内部的读锁会自动释放
// 在多线程中使用
let map_arc = Arc::new(DashMap::new());
let mut handles = vec![];
for i in 0..10 {
let map_clone = Arc::clone(&map_arc);
let handle = thread::spawn(move || {
map_clone.insert(i, format!("value_{}", i));
});
handles.push(handle);
}
for handle in handles {
handle.join().unwrap();
}
assert_eq!(map_arc.len(), 10);
println!("Map after concurrent inserts: {:?}", map_arc);
}
对比我们的实现：
- 简洁性：
DashMap的insert和get无需.lock()或.read()，API 更干净。 - 返回值：
get返回的是一个Ref守卫，它持有着分片的读锁。这意味着只要Ref存在，你就不能对该分片进行写操作。这也意味着你不能直接从get的结果中移出（move out）值，通常需要克隆。
修改和删除
对于写操作，DashMap 同样提供了简洁的 API。
use dashmap::DashMap;
fn main() {
let map = DashMap::new();
map.insert("counter", 0);
// 直接修改一个值
// get_mut 返回一个 RefMut<'_, K, V>，类似于写锁守卫
if let Some(mut counter) = map.get_mut("counter") {
*counter += 1;
}
assert_eq!(*map.get("counter").unwrap(), 1);
// 删除一个键值对
let removed = map.remove("counter");
assert_eq!(removed, Some(("counter".to_string(), 1)));
assert!(map.is_empty());
}
对比我们的实现：
get_mut提供了安全的可变访问，返回一个RefMut守卫，它独占地锁定了该分片。- 我们的实现没有提供
get_mut这样的 API，只能通过remove然后insert来模拟，这不是原子的。
DashMap 的原子操作：entry API
就像 HashMap 一样，DashMap 也提供了强大的 entry API 来实现原子性的“检查并更新”操作。这对于避免竞态条件至关重要。
use dashmap::DashMap;
use std::sync::Arc;
use std::thread;
// 经典案例：并发词频统计
fn main() {
let word_counts = Arc::new(DashMap::new());
let text = "hello world rust is fast hello rust";
let mut handles = vec![];
for word in text.split_whitespace() {
let word = word.to_string();
let counts_clone = Arc::clone(&word_counts);
let handle = thread::spawn(move || {
// entry() 会锁定对应的分片，并返回一个 Entry
// or_insert(0) 如果键不存在，则插入 0
// 然后对值进行操作，整个过程是原子的
*counts_clone.entry(word).or_insert(0) += 1;
});
handles.push(handle);
}
for handle in handles {
handle.join().unwrap();
}
assert_eq!(*word_counts.get("hello").unwrap(), 2);
assert_eq!(*word_counts.get("rust").unwrap(), 2);
assert_eq!(*word_counts.get("world").unwrap(), 1);
println!("Word counts: {:?}", word_counts);
}
entry API 的魔力：
map.entry(key): 这个操作会计算键的哈希，并锁定对应的分片。然后它返回一个Entry对象，该对象持有分片的写锁。.or_insert(default): 在持有锁的情况下，检查键是否存在。如果不存在，插入default值。*... += 1:or_insert返回一个RefMut，我们可以直接对其解引用并修改。- 整个
entry(...).or_insert(...)...链式调用结束，Entry和RefMut被销毁，分片的写锁被释放。
这完美地解决了我们上一章 get 然后 insert 的原子性问题，代码既简洁又绝对安全。
DashMap 的引用类型：Ref 和 RefMut
当你调用 get, get_mut, entry 等方法时，返回的不是值本身，而是 Ref 或 RefMut 类型的智能指针。理解它们是正确使用 dashmap 的关键。
Ref<'_, K, V>:- 行为类似于
&V。 - 实现了
Deref<Target=V>，所以你可以像使用&V一样使用它。 - 持有一个分片的读锁。只要
Ref存在，该分片就不能被写入。
- 行为类似于
RefMut<'_, K, V>:- 行为类似于
&mut V。 - 实现了
Deref<Target=V>和DerefMut。 - 持有一个分片的写锁。只要
RefMut存在，该分片就不能被任何其他线程读取或写入。
- 行为类似于
use dashmap::DashMap;
fn main() {
let map = DashMap::new();
map.insert("key", 10);
// 获取一个 Ref
let value_ref = map.get("key").unwrap();
// value_ref 持有读锁，我们可以进行读操作
println!("Value is: {}", *value_ref);
// 下面的代码会死锁！
// 因为当前作用域已经持有了 "key" 所在分片的读锁 (通过 value_ref)。
// 现在我们又尝试获取同一个分片的写锁，但写锁必须等待所有读锁释放。
// 而读锁要等到 value_ref 离开作用域才能释放。这是一个经典的死锁。
// map.insert("key", 20); // deadlock!
// 正确的做法是先释放读锁
drop(value_ref);
// 现在可以安全地写入了
map.insert("key", 20);
assert_eq!(*map.get("key").unwrap(), 20);
}
这个例子非常重要，它揭示了 dashmap 简洁 API 背后的锁机制。你虽然看不见 lock()，但锁是真实存在的。忘记 Ref 和 RefMut 会自动释放锁，就可能导致死锁。
性能优化技巧与高级用法
1. 选择合适的容量
和 HashMap 一样，预先分配容量可以避免多次扩容带来的性能开销。
// 如果你大概知道需要存储多少元素，使用 with_capacity
let map = DashMap::with_capacity(1000);
2. 避免持有锁过长时间
Ref 和 RefMut 持有锁，应该让它们的生命周期尽可能短。
use dashmap::DashMap;
fn bad_practice(map: &DashMap<String, Vec<u8>>) {
if let Some(large_vec_ref) = map.get("large_data") {
// 在持有锁的同时进行耗时操作
// 这会长时间阻塞对该分片的写操作
for byte in large_vec_ref.iter() {
// 模拟耗时操作
std::thread::sleep(std::time::Duration::from_millis(1));
}
}
}
fn good_practice(map: &DashMap<String, Vec<u8>>) {
// 仅在需要时获取锁，并尽快释放
let data_clone = {
// 创建一个独立的作用域来限制 Ref 的生命周期
map.get("large_data").map(|v| v.clone())
}; // 锁在这里被释放
if let Some(data) = data_clone {
// 现在可以在不持有锁的情况下进行耗时操作
for byte in data.iter() {
std::thread::sleep(std::time::Duration::from_millis(1));
}
}
}
3. 使用 alter 和 alter_all 进行批量原子操作
如果你需要对一个值进行一系列复杂的原子修改，或者同时修改多个值，可以使用 alter 和 alter_all。
use dashmap::DashMap;
fn main() {
let map = DashMap::new();
map.insert("user:1", 100);
// alter: 对单个键进行原子修改
map.alter("user:1", |_, mut v| {
v -= 10;
v
});
assert_eq!(*map.get("user:1").unwrap(), 90);
// alter_all: 同时对多个键进行原子修改
// 注意：这会锁定整个哈希表！
map.alter_all(|_, mut v| {
v *= 2;
v
});
assert_eq!(*map.get("user:1").unwrap(), 180);
}
4. DashMap 的迭代
DashMap 提供了迭代器，但你需要注意它的行为。iter() 和 iter_mut() 会锁定整个表，直到迭代器被销-毁。这在某些情况下可能会成为性能瓶颈。
use dashmap::DashMap;
fn main() {
let map = DashMap::new();
map.insert("a", 1);
map.insert("b", 2);
// iter() 会锁定整个表
for item in map.iter() {
println!("key: {}, value: {}", item.key(), *item.value());
}
// 迭代器在这里被销毁，锁被释放
// 一个更轻量级的、不持有锁的迭代方式是先克隆
// DashMap 的 clone 是一个轻量操作
let map_clone = map.clone();
for item in map_clone.into_iter() {
// ...
println!("(cloned) key: {}, value: {}", item.0, item.1);
}
}
如果你只想获取一个快照而不阻塞写操作，可以 .clone() 整个 DashMap。DashMap 的 clone 是一个相对轻量的操作，它会克隆所有的分片（Arc），而不是深度克隆所有数据。
基准测试对比
让我们通过一个简单的基准测试来对比 DashMap, 我们自制的 ConcurrentHashMap 和 Arc<RwLock<HashMap>>。
(完整的基准测试代码需要 criterion 库以及将上一章的代码整理为 lib)
预期的测试结果 (在读多写少场景下):
Arc<RwLock<HashMap>>: 性能最差，因为它的“一把大锁”成为了并发瓶颈。- 我们自制的
ConcurrentHashMap: 性能会比RwLock<HashMap>好得多，证明了分片策略的有效性。 DashMap: 性能通常是最好的，因为它内部有更多优化，例如更高效的哈希算法、缓存行对齐、动态扩容等。
总结
DashMap 是 Rust 并发编程的利器。它将复杂的并发控制逻辑封装起来，提供了既安全又易用的 API。
核心要点：
- 忘记
lock()：DashMap让你像使用标准HashMap一样操作并发数据，极大地提升了开发体验。 - 理解
Ref和RefMut：它们是DashMap安全的基石，其生命周期管理着内部锁的释放，需要小心处理以避免死锁。 - 使用原子 API：优先使用
entryAPI 来执行“检查并更新”操作，保证原子性。 - 注意锁的粒度和持有时间：尽管
DashMap是分片的，但长时间持有Ref或RefMut仍然会阻塞对该分片的操作。 - 在生产环境中优先选择
DashMap：相比于自己实现或使用RwLock<HashMap>，DashMap在绝大多数场景下都是更好、更安全、性能更高的选择。
通过本章的学习，你不仅掌握了一个强大的并发工具，更重要的是，通过与我们自己实现的并发哈希表对比，你对并发数据结构的设计和权衡有了更深刻的理解。
思考题
DashMap的get方法返回Option<Ref<...>>。为什么它不直接返回Option<V>(通过克隆) 或者Option<&V>？这三种设计各有什么优缺点？DashMap的iter()方法会锁定整个表。如果我想遍历DashMap并对每个值进行修改，同时又不想长时间锁定整个表，你会如何实现？DashMap内部的分片数量是固定的。如果我想实现一个可以动态增加分片数量的DashMap，你会如何设计？（提示：这非常复杂，思考一下大致思路即可）。- 在什么极端情况下，
DashMap的性能可能会退化到和RwLock<HashMap>差不多？ DashMap的entry()API 是如何保证原子性的？请描述一下它内部可能的工作流程。
实践练习
- 实现一个线程安全的 LRU 缓存：使用
DashMap和VecDeque（或者一个双向链表）来实现一个 LRU (Least Recently Used) 缓存。DashMap用于快速查找，而VecDeque用于记录访问顺序。所有操作都需要是线程安全的。 - 重构并发 Web 访问计数器：将上一章练习中基于
Arc<Mutex<u64>>的 Web 访问计数器，改用DashMap<String, u64>来实现。Key 可以是 URL 路径，Value 是该路径的访问次数。对比两种实现的性能和代码复杂度。 - 基准测试不同的
entry用法：编写一个基准测试，对比*map.entry(key).or_insert(0) += 1和if let Some(mut v) = map.get_mut(&key) { *v += 1; } else { map.insert(key, 1); }这两种写法的性能。分析为什么entryAPI 通常更快。
更多推荐
0
0- 0
已为社区贡献271条内容
所有评论(0)