Rust中函数记忆化最佳实践：无需额外缓存变量的实现方案

针对你手动传HashMap实现记忆化但不想重复创建缓存的问题，Rust里有几种实用方案，对标Python的@cache装饰器：

1. 用第三方库（最省心） #

直接用现成的crates可以实现类似Python装饰器的一键记忆化，比如memoize crate：

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

[dependencies]
memoize = "0.4"

然后给函数加#[memoize]注解即可：

use memoize::memoize;

#[memoize]
fn foo(num: usize) -> usize {
    // 替换成你的函数逻辑，比如斐波那契示例：
    if num <= 1 {
        num
    } else {
        foo(num - 1) + foo(num - 2)
    }
}

这个库会自动帮你创建并管理缓存，无需手动处理HashMap，用法和Python的@cache几乎一致。

2. 手动写宏（无依赖自定义） #

如果不想引入第三方库，可以自己写一个宏来封装缓存逻辑，自动为函数添加静态缓存：

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

// 定义记忆化宏，支持单参数函数
macro_rules! memoized {
    ($func_name:ident ($arg_type:ty) -> $ret_type:ty $func_body:block) => {
        fn $func_name(arg: $arg_type) -> $ret_type {
            // 静态缓存，用Mutex保证多线程安全
            static mut CACHE: Option<Mutex<HashMap<$arg_type, $ret_type>>> = None;
            
            unsafe {
                // 初始化缓存（仅第一次调用时执行）
                if CACHE.is_none() {
                    CACHE = Some(Mutex::new(HashMap::new()));
                }
                
                let mut cache = CACHE.as_ref().unwrap().lock().unwrap();
                // 命中缓存直接返回
                if let Some(&result) = cache.get(&arg) {
                    return result;
                }
                
                // 执行原函数逻辑并缓存结果
                let result = (|| $func_body)(arg);
                cache.insert(arg, result);
                result
            }
        }
    };
}

// 使用宏定义记忆化函数
memoized!(foo(usize) -> usize {
    if arg <= 1 {
        arg
    } else {
        foo(arg - 1) + foo(arg - 2)
    }
});

如果是单线程场景，可以去掉Mutex简化代码，减少开销。

3. 装饰器模式（灵活定制） #

如果需要自定义缓存策略（比如LRU淘汰、过期时间），可以用装饰器模式把函数和缓存包装成结构体：

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

// 定义记忆化包装器
struct Memoized<F> {
    inner_func: F,
    cache: Mutex<HashMap<usize, usize>>,
}

impl<F> Memoized<F>
where
    F: Fn(usize) -> usize,
{
    // 创建新的记忆化包装器
    fn new(func: F) -> Self {
        Memoized {
            inner_func: func,
            cache: Mutex::new(HashMap::new()),
        }
    }

    // 调用记忆化后的函数
    fn run(&self, num: usize) -> usize {
        let mut cache = self.cache.lock().unwrap();
        match cache.get(&num) {
            Some(&val) => val,
            None => {
                let result = (self.inner_func)(num);
                cache.insert(num, result);
                result
            }
        }
    }
}

// 原函数（未记忆化）
fn raw_foo(num: usize) -> usize {
    if num <= 1 {
        num
    } else {
        raw_foo(num - 1) + raw_foo(num - 2)
    }
}

// 使用示例
fn main() {
    let memoized_foo = Memoized::new(raw_foo);
    println!("斐波那契第10项：{}", memoized_foo.run(10));
}

这种方式适合需要对缓存做精细化控制的场景，比如搭配lru crate实现LRU缓存限制内存占用。

关键注意点 #

• 线程安全：多线程环境下必须用Mutex或RwLock保护缓存，避免数据竞争。
• 缓存键约束：作为缓存键的类型必须实现Hash和Eq trait，Rust基本类型都默认支持，自定义类型需要手动实现这两个trait。
• 内存管理：全局静态缓存会常驻内存，若缓存数据量大，建议用LRU等有淘汰策略的缓存。

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