如何在Rust不同代码模块中实现可写静态对象？

问题背景 #

我习惯使用C++，它允许在全局命名空间、用户定义命名空间或类中使用可写静态对象，但在Rust中这一方式并不合规。若要实现类似功能，必须用unsafe包裹对static mut变量的写入操作，且我了解到static mut甚至可能被移除或废弃。

我的代码场景如下：

use std::collections::HashMap;

static mut my_dict: HashMap<u32, u32>;

fn main() {
    dosomething();
}

fn dosomething() -> () {
    /* 可能从当前模块或其他模块写入 */
    my_dict.insert(3, 3);
}

已考虑的方案 #

• 用unsafe {}包裹所有写入操作：虽然可以适应Rust的强制要求，但如果static mut被移除或废弃，该方案不可行。
• 依赖注入：将对象作为参数传递给所有需要它的函数，但这种方式并不现实。

可选替代方案 #

1. 使用lazy_static + 同步原语（Mutex/RwLock） #

这是Rust中实现全局可写共享对象最常用的方式，lazy_static用于延迟初始化全局静态对象，Mutex或RwLock保证多线程环境下的安全访问，全程无需手动编写unsafe代码。

示例代码：

use std::collections::HashMap;
use std::sync::Mutex;
use lazy_static::lazy_static;

lazy_static! {
    static ref MY_DICT: Mutex<HashMap<u32, u32>> = Mutex::new(HashMap::new());
}

fn main() {
    dosomething();
}

fn dosomething() {
    // 锁定Mutex以获取写入权限
    let mut dict = MY_DICT.lock().unwrap();
    dict.insert(3, 3);
}

• 优点：线程安全，无需手动unsafe，兼容性好。
• 缺点：每次访问需要锁定，有轻微性能开销；unwrap()可能在Mutex中毒时 panic，实际项目中建议用match或?处理错误。

2. 使用标准库OnceLock（Rust 1.70+） #

Rust 1.70版本后，标准库提供了std::sync::OnceLock，可以用来安全地初始化全局静态对象，结合同步原语使用，无需额外依赖第三方crate。

示例代码：

use std::collections::HashMap;
use std::sync::{Mutex, OnceLock};

static MY_DICT: OnceLock<Mutex<HashMap<u32, u32>>> = OnceLock::new();

fn main() {
    // 初始化全局对象（仅执行一次）
    MY_DICT.set(Mutex::new(HashMap::new())).unwrap();
    dosomething();
}

fn dosomething() {
    let dict = MY_DICT.get().unwrap();
    let mut inner = dict.lock().unwrap();
    inner.insert(3, 3);
}

• 优点：无需第三方依赖，初始化逻辑明确。
• 缺点：需要手动处理初始化，未初始化时调用get()会返回None，需注意错误处理。

3. 线程局部存储（thread_local!） #

如果你的HashMap不需要跨线程共享，仅在单个线程内使用，那么可以用thread_local!创建线程局部的静态对象，每个线程拥有独立的实例，无需同步，访问和修改都安全。

示例代码：

use std::collections::HashMap;
use std::cell::RefCell;

thread_local! {
    static MY_DICT: RefCell<HashMap<u32, u32>> = RefCell::new(HashMap::new());
}

fn main() {
    dosomething();
}

fn dosomething() {
    MY_DICT.with(|dict| {
        let mut inner = dict.borrow_mut();
        inner.insert(3, 3);
    });
}

• 优点：无同步开销，访问速度快，无需unsafe。
• 缺点：对象是线程隔离的，不同线程无法共享数据。

4. 封装全局单例结构体 #

可以将HashMap封装到一个结构体中，通过静态实例提供安全的访问接口，内部用同步原语保护数据，这种方式更符合Rust的封装理念。

示例代码：

use std::collections::HashMap;
use std::sync::Mutex;
use lazy_static::lazy_static;

struct GlobalDict {
    inner: Mutex<HashMap<u32, u32>>,
}

impl GlobalDict {
    fn insert(&self, key: u32, value: u32) {
        let mut inner = self.inner.lock().unwrap();
        inner.insert(key, value);
    }

    fn get(&self, key: &u32) -> Option<&u32> {
        let inner = self.inner.lock().unwrap();
        inner.get(key)
    }
}

lazy_static! {
    static ref GLOBAL_DICT: GlobalDict = GlobalDict {
        inner: Mutex::new(HashMap::new()),
    };
}

fn main() {
    dosomething();
}

fn dosomething() {
    GLOBAL_DICT.insert(3, 3);
}

• 优点：封装性好，对外暴露的接口更清晰，便于扩展功能。
• 缺点：需要额外编写结构体和方法，有一定代码量。

内容的提问来源于stack exchange，提问作者Zebrafish