Rust 2026 经验谈 - 共享状态并发实战

1
use std::sync::{Mutex, RwLock};
2

3
// Mutex：同一时刻只有一个线程能访问（无论读写）
4
let mutex_data: Mutex<Vec<i32>> = Mutex::new(vec![]);
5
{
6
    let mut guard = mutex_data.lock().unwrap();
7
    guard.push(42);  // 独占访问，无论读还是写
8
}
9

10
// RwLock：允许多个读者同时访问，或一个写者独占
11
let rwlock_data: RwLock<Vec<i32>> = RwLock::new(vec![]);
12
{
13
    let guard = rwlock_data.read().unwrap();  // 共享读
14
    println!("长度: {}", guard.len());
15
}
16
{
17
    let mut guard = rwlock_data.write().unwrap();  // 独占写
18
    guard.push(42);
19
}

1
use std::sync::Mutex;
2

3
struct LayeredLocks {
4
    // 层级 0：最底层，先锁
5
    config: Mutex<Config>,
6
    // 层级 1：中间层
7
    cache: Mutex<Cache>,
8
    // 层级 2：最顶层，最后锁
9
    stats: Mutex<Stats>,
10
}
11

12
struct Config { max_size: usize }
13
struct Cache { entries: Vec<String> }
14
struct Stats { hits: usize, misses: usize }
15

16
impl LayeredLocks {
17
    fn update_cache(&self, key: String) {
18
        // 正确：config(0) → cache(1) → stats(2)，层级递增
19
        let config = self.config.lock().unwrap();
20
        let mut cache = self.cache.lock().unwrap();
21
        let mut stats = self.stats.lock().unwrap();
22

23
        if config.max_size > cache.entries.len() {
24
            cache.entries.push(key);
25
            stats.hits += 1;
26
        } else {
27
            stats.misses += 1;
28
        }
29
    }
30

31
    // fn bad_order(&self) {
32
    //     // 错误：stats(2) → config(0)，层级递减！
33
    //     let stats = self.stats.lock().unwrap();
34
    //     let config = self.config.lock().unwrap(); // 可能死锁
35
    // }
36
}

1
use std::sync::Mutex;
2
use std::marker::PhantomData;
3

4
struct LockLevel<const N: u8>;
5

6
struct HierarchicalLock<T, const N: u8> {
7
    inner: Mutex<T>,
8
    _level: PhantomData<LockLevel<N>>,
9
}
10

11
impl<T, const N: u8> HierarchicalLock<T, N> {
12
    fn new(data: T) -> Self {
13
        Self {
14
            inner: Mutex::new(data),
15
            _level: PhantomData,
16
        }
17
    }
18

19
    fn lock(&self) -> (std::sync::MutexGuard<'_, T>, u8) {
20
        // 返回 guard 和层级号，供运行时检查
21
        (self.inner.lock().unwrap(), N)
22
    }
23
}
24

25
// 使用
26
struct App {
27
    level0: HierarchicalLock<Config, 0>,
28
    level1: HierarchicalLock<Cache, 1>,
29
    level2: HierarchicalLock<Stats, 2>,
30
}

1
use std::sync::Mutex;
2
use std::time::{Duration, Instant};
3

4
fn try_lock_with_timeout<'a, T>(
5
    lock: &'a Mutex<T>,
6
    timeout: Duration,
7
) -> Option<std::sync::MutexGuard<'a, T>> {
8
    let start = Instant::now();
9
    loop {
10
        match lock.try_lock() {
11
            Ok(guard) => return Some(guard),
12
            Err(std::sync::TryLockError::WouldBlock) => {
13
                if start.elapsed() > timeout {
14
                    return None; // 超时
15
                }
16
                std::hint::spin_loop();
17
            }
18
            Err(std::sync::TryLockError::Poisoned(_)) => {
19
                // 锁被毒化，决定是否继续
20
                return lock.lock().ok();
21
            }
22
        }
23
    }
24
}

1
use std::sync::Mutex;
2

3
let data = Mutex::new(vec![]);
4

5
// 坏：持锁时间过长
6
{
7
    let mut guard = data.lock().unwrap();
8
    for i in 0..1000 {
9
        guard.push(i);  // 1000 次 push 都在锁内
10
    }
11
    let result = expensive_computation();  // 不需要锁的计算也在锁内！
12
    guard.push(result);
13
}
14

15
// 好：缩短持锁范围
16
{
17
    let result = expensive_computation();  // 先在锁外计算
18
    let mut guard = data.lock().unwrap();
19
    for i in 0..1000 {
20
        guard.push(i);
21
    }
22
    guard.push(result);
23
    // guard 在这里 drop，释放锁
24
}

1
use std::sync::Arc;
2

3
fn build_then_share() -> Arc<Vec<String>> {
4
    let mut data = Arc::new(Vec::with_capacity(1000));
5

6
    // 构建阶段：单线程，用 get_mut 避免原子开销
7
    if let Some(vec) = Arc::get_mut(&mut data) {
8
        for i in 0..1000 {
9
            vec.push(format!("item-{i}"));
10
        }
11
    }
12

13
    // 发布阶段：Arc 被克隆到多线程
14
    data
15
}

1
use std::sync::{Arc, Weak};
2
use std::collections::HashMap;
3

4
struct CacheEntry {
5
    key: String,
6
    data: Vec<u8>,
7
}
8

9
struct Cache {
10
    entries: HashMap<String, Weak<CacheEntry>>,
11
}
12

13
impl Cache {
14
    fn get(&mut self, key: &str) -> Option<Arc<CacheEntry>> {
15
        if let Some(weak) = self.entries.get(key) {
16
            if let Some(strong) = weak.upgrade() {
17
                return Some(strong);  // 条目仍然存活
18
            }
19
        }
20
        // 条目已被回收，从缓存中移除
21
        self.entries.remove(key);
22
        None
23
    }
24

25
    fn insert(&mut self, entry: Arc<CacheEntry>) {
26
        self.entries.insert(
27
            entry.key.clone(),
28
            Arc::downgrade(&entry),
29
        );
30
    }
31
}

1
use std::sync::Arc;
2

3
// 陷阱 1：频繁 clone Arc（每次 clone 一次原子操作）
4
fn bad_many_clones(arc: &Arc<Vec<i32>>) {
5
    for _ in 0..10000 {
6
        let _clone = arc.clone();  // 10000 次原子 fetch_add + fetch_sub
7
    }
8
}
9

10
// 优化：传引用
11
fn good_pass_ref(arc: &Arc<Vec<i32>>) {
12
    for _ in 0..10000 {
13
        let _ref: &Vec<i32> = &**arc;  // 零开销
14
    }
15
}

1
use std::sync::{Arc, RwLock};
2
use std::collections::HashMap;
3
use std::time::{Instant, Duration};
4

5
pub struct SimpleCache<V> {
6
    inner: RwLock<HashMap<String, (V, Instant)>>,
7
    ttl: Duration,
8
}
9

10
impl<V: Clone> SimpleCache<V> {
11
    pub fn new(ttl: Duration) -> Self {
12
        Self {
13
            inner: RwLock::new(HashMap::new()),
14
            ttl,
15
        }
16
    }
17

18
    pub fn get(&self, key: &str) -> Option<V> {
19
        let inner = self.inner.read().unwrap();
20
        inner.get(key).and_then(|(v, inserted)| {
21
            if inserted.elapsed() < self.ttl {
22
                Some(v.clone())
23
            } else {
24
                None
25
            }
26
        })
27
    }
28

29
    pub fn insert(&self, key: String, value: V) {
30
        let mut inner = self.inner.write().unwrap();
31
        inner.insert(key, (value, Instant::now()));
32
    }
33

34
    pub fn remove_expired(&self) {
35
        let mut inner = self.inner.write().unwrap();
36
        let now = Instant::now();
37
        inner.retain(|_, (_, inserted)| now - *inserted < self.ttl);
38
    }
39
}

1
use std::sync::{Arc, RwLock};
2
use std::collections::HashMap;
3
use std::time::{Instant, Duration};
4

5
const NUM_SHARDS: usize = 16;
6

7
pub struct ShardedCache<V> {
8
    shards: [RwLock<HashMap<String, (V, Instant)>>; NUM_SHARDS],
9
    ttl: Duration,
10
}
11

12
impl<V: Clone> ShardedCache<V> {
13
    pub fn new(ttl: Duration) -> Self {
14
        Self {
15
            shards: core::array::from_fn(|_| RwLock::new(HashMap::new())),
16
            ttl,
17
        }
18
    }
19

20
    fn shard_index(&self, key: &str) -> usize {
21
        // 用 key 的哈希值决定分片
22
        let hash = key.bytes().fold(0u64, |acc, b| acc.wrapping_mul(31).wrapping_add(b as u64));
23
        (hash as usize) % NUM_SHARDS
24
    }
25

26
    pub fn get(&self, key: &str) -> Option<V> {
27
        let idx = self.shard_index(key);
28
        let shard = self.shards[idx].read().unwrap();
29
        shard.get(key).and_then(|(v, inserted)| {
30
            if inserted.elapsed() < self.ttl {
31
                Some(v.clone())
32
            } else {
33
                None
34
            }
35
        })
36
    }
37

38
    pub fn insert(&self, key: String, value: V) {
39
        let idx = self.shard_index(&key);
40
        let mut shard = self.shards[idx].write().unwrap();
41
        shard.insert(key, (value, Instant::now()));
42
    }
43
}

1
use dashmap::DashMap;
2
use std::time::{Instant, Duration};
3
use std::sync::Arc;
4

5
pub struct DashCache<V> {
6
    inner: DashMap<String, (V, Instant)>,
7
    ttl: Duration,
8
}
9

10
impl<V: Clone> DashCache<V> {
11
    pub fn new(ttl: Duration) -> Self {
12
        Self {
13
            inner: DashMap::new(),
14
            ttl,
15
        }
16
    }
17

18
    pub fn get(&self, key: &str) -> Option<V> {
19
        self.inner.get(key).and_then(|entry| {
20
            let (v, inserted) = entry.value();
21
            if inserted.elapsed() < self.ttl {
22
                Some(v.clone())
23
            } else {
24
                None
25
            }
26
        })
27
    }
28

29
    pub fn insert(&self, key: String, value: V) {
30
        self.inner.insert(key, (value, Instant::now()));
31
    }
32

33
    pub fn remove_expired(&self) {
34
        let now = Instant::now();
35
        self.inner.retain(|_, (_, inserted)| now - *inserted < self.ttl);
36
    }
37
}