Rust全局作用域内闭包的生命周期问题及解决方案咨询

原始代码与错误 #

最小复现代码：

use std::collections::HashMap;
fn main() {
  let mut map : HashMap<String, String> = HashMap::new();
  map.insert(String::from("a"), String::from("first"));
  map.insert(String::from("b"), String::from("second"));

  let mut funcs: Vec<Box<dyn FnMut(String) -> ()>> = Vec::new(); 
  for (key, val) in map { 
    funcs.push(Box::new(|v| {
      println!("{} : {} : {}",key,val,v);
    }))
  }

  for mut func in funcs {
    func(String::from("c"));
  }
}

错误信息（val同理）：

`key` does not live long enough
values in a scope are dropped in the opposite order they are defined rustcE0597
main.rs(12, 5): `key` dropped here while still borrowed
main.rs(9, 29): value captured here
main.rs(17, 1): borrow might be used here, when `funcs` is dropped and runs the 
`Drop` code for type `Vec`

场景：需先构建HashMap，再遍历生成一组闭包供后续执行。已知错误原因是循环中key/val生命周期仅到当前循环结束，闭包延迟执行时访问已销毁数据，但尝试into_iter()、drain()、Rc包装均无效。

补充问题1 #

添加move关键字后示例正常，但实际代码遇两个问题：

• Map值类型为Vec<MyStruct>，结构体不可拷贝，无法转移所有权（结构体很小，由一组Option组成）。
• 多个闭包需借用另一个不可变HashMap，从第二个闭包开始出现use of moved value错误。

补充问题2（move导致共享HashMap报错示例） #

代码：

fn main() {
let mut map : HashMap<String, Vec<String>> = HashMap::new();
map.insert(String::from("a"), Vec::from([String::from("first")]));
map.insert(String::from("b"), Vec::from([String::from("first")]));

let map2 : HashMap<String, Vec<String>> = HashMap::new();

let mut funcs: Vec<Box<dyn FnMut(String) -> ()>> = Vec::new(); 
for (key, val) in map { 
    funcs.push(Box::new(move |v| {
        println!("{} : {:?} : {}, {}",key,val,v, map2.capacity());
    }))
}

for mut func in funcs {
    func(String::from("c"));
}

错误信息：

use of moved value: `map2`
value moved into closure here, in previous iteration of looprustcE0382
main.rs(12, 54): use occurs due to use in closure
main.rs(7, 9): move occurs because `map2` has type `HashMap<String, Vec<String>>`, which does not implement the `Copy` trait

疑问：是否只能使用可拷贝数据？若可以，如何将HashMap包装为可拷贝结构体？或是有其他方案？

1. 修复闭包捕获变量的生命周期问题 #

原始错误核心是：闭包默认借用循环中的key和val，但这些变量在循环迭代结束后立即销毁，闭包后续执行时会访问无效内存。添加move关键字让闭包获取变量所有权，变量会被转移到闭包内部，生命周期与闭包一致：

// 修改后的循环代码
for (key, val) in map { 
    funcs.push(Box::new(move |v| {
        println!("{} : {} : {}", key, val, v);
    }))
}

2. 处理不可拷贝的Vec<MyStruct> #

情况1：结构体可实现Copy #

若MyStruct仅包含Copy类型（如Option<i32>、bool等），直接为其派生Copy和Clone trait即可：

#[derive(Copy, Clone, Debug)]
struct MyStruct {
    opt1: Option<i32>,
    opt2: Option<bool>,
}

此时Vec<MyStruct>虽不可Copy，但可以通过clone()复制整个向量（因结构体本身拷贝开销极小）：

for (key, val) in map { 
    let val_clone = val.clone();
    funcs.push(Box::new(move |v| {
        println!("{} : {:?} : {}", key, val_clone, v);
    }))
}

情况2：结构体包含不可Copy类型 #

若结构体包含String这类不可Copy类型，无法实现Copy，需用Rc（单线程）或Arc（多线程）共享所有权：

use std::rc::Rc;

// 遍历Map时将val包装为Rc
for (key, val) in map { 
    let val_rc = Rc::new(val);
    funcs.push(Box::new(move |v| {
        println!("{} : {:?} : {}", key, val_rc, v);
    }))
}

Rc仅拷贝引用计数指针，开销极小，所有闭包执行完毕后，原数据才会被销毁。多线程场景替换为Arc即可。

3. 解决多闭包共享不可变HashMap的问题 #

用Rc（单线程）或Arc（多线程）包装共享的HashMap，每个闭包持有一个引用计数副本：

use std::collections::HashMap;
use std::rc::Rc;

fn main() {
let mut map : HashMap<String, Vec<String>> = HashMap::new();
map.insert(String::from("a"), Vec::from([String::from("first")]));
map.insert(String::from("b"), Vec::from([String::from("first")]));

// 用Rc包装map2实现共享
let map2 = Rc::new(HashMap::<String, Vec<String>>::new());

let mut funcs: Vec<Box<dyn FnMut(String) -> ()>> = Vec::new(); 
for (key, val) in map { 
    // 克隆Rc指针（仅拷贝引用计数，无性能损耗）
    let map2_clone = Rc::clone(&map2);
    funcs.push(Box::new(move |v| {
        println!("{} : {:?} : {}, {}", key, val, v, map2_clone.capacity());
    }))
}

for mut func in funcs {
    func(String::from("c"));
}

• Rc::clone不会复制整个HashMap，仅增加引用计数，完全可以忽略开销。
• 多线程环境下，将Rc替换为Arc即可，Arc是线程安全的引用计数容器。

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