Rust模块函数调用间如何存储状态？需保留原有API

嘿，这个问题我太熟悉了！Rust确实不像有些高级语言那样能直接在模块作用域定义个可变变量就跨函数共享，但咱们有安全且优雅的办法实现，而且完全不用改动你现有的公开API。

核心思路是用线程安全的静态缓存，因为模块级的全局变量需要满足Rust的安全规则——不可变性和线程安全。这里推荐两种方案，都能完美适配你的需求：

方案一：使用lazy_static（最常用） #

首先需要在Cargo.toml里添加依赖：

[dependencies]
lazy_static = "1.4"

然后修改你的模块代码，加入静态缓存并改造total_for_square：

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

// 定义模块级的线程安全缓存，延迟初始化
lazy_static! {
    static ref SQUARE_TOTAL_CACHE: Mutex<HashMap<u32, u64>> = Mutex::new(HashMap::new());
}

pub fn square(s: u32) -> u64 {
    if s < 1 || s > 64 {
        panic!("Square must be between 1 and 64")
    }
    total_for_square(s) - total_for_square(s - 1)
}

fn total_for_square(s: u32) -> u64 {
    // 先尝试从缓存读取
    let mut cache = SQUARE_TOTAL_CACHE.lock().unwrap();
    if let Some(&cached_val) = cache.get(&s) {
        return cached_val;
    }

    // 缓存未命中时计算结果
    let result = if s == 64 {
        u64::max_value()
    } else {
        2u64.pow(s) - 1
    };

    // 将结果存入缓存，供后续调用使用
    cache.insert(s, result);
    result
}

pub fn total() -> u64 {
    u64::max_value()
}

关键细节解释： #

• lazy_static!宏帮我们实现了延迟初始化，缓存只会在第一次被访问时创建，避免不必要的内存占用。
• Mutex用来保证线程安全：因为静态变量是全局共享的，多个线程同时访问时必须通过互斥锁保护，防止数据竞争。
• 你的公开API（square和total）完全保持原样，外部调用者感知不到任何变化。

方案二：使用标准库的OnceLock（无额外依赖） #

如果你不想引入第三方依赖，可以用Rust 1.63+版本标准库提供的OnceLock：

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

// 静态缓存容器，通过OnceLock实现线程安全的初始化
static SQUARE_TOTAL_CACHE: OnceLock<Mutex<HashMap<u32, u64>>> = OnceLock::new();

// 辅助函数，获取缓存实例
fn get_cache() -> &'static Mutex<HashMap<u32, u64>> {
    SQUARE_TOTAL_CACHE.get_or_init(|| Mutex::new(HashMap::new()))
}

pub fn square(s: u32) -> u64 {
    if s < 1 || s > 64 {
        panic!("Square must be between 1 and 64")
    }
    total_for_square(s) - total_for_square(s - 1)
}

fn total_for_square(s: u32) -> u64 {
    let mut cache = get_cache().lock().unwrap();
    if let Some(&cached_val) = cache.get(&s) {
        return cached_val;
    }

    let result = if s == 64 {
        u64::max_value()
    } else {
        2u64.pow(s) - 1
    };

    cache.insert(s, result);
    result
}

pub fn total() -> u64 {
    u64::max_value()
}

这种方案完全基于标准库，不需要额外依赖，逻辑和方案一本质相同，只是初始化方式不同。

额外提示 #

• 因为你的缓存最多只会存储64个条目（s从0到64），内存占用可以忽略不计，性能提升非常明显，尤其是在高频调用场景下。
• 关于lock().unwrap()：如果另一个线程持有锁时发生panic，锁会进入"poisoned"状态，unwrap会触发panic。如果需要更健壮的错误处理，可以改成match或expect来捕获这种情况。

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