Rust中临时值借用时丢弃问题：如何处理Path列表引用？

问题场景 #

需要将路径列表（Vec或数组）传递给异步/多线程函数，每个路径用于生成线程处理对应文件，但为适配线程需求给函数参数添加'static生命周期后，调用时无法满足生命周期要求，出现编译错误。

原代码 #

use std::path::{Path, PathBuf};

fn main() {
    // 获取路径列表
    let paths = vec![
        PathBuf::from("/path/to/file.txt"),
        PathBuf::from("/path/to/file2.txt"),
    ];

    // 多线程处理这些路径
    do_something(&paths.iter().map(|path| path.as_path()).collect::<Vec<_>>());

    // 后续还要对这些文件执行其他操作
}

fn do_something(paths: &'static [&Path]) {
    // 这里需要使用paths，且要求'static生命周期
}

编译报错 #

error[E0597]: `paths` does not live long enough
  --> src\main.rs:11:19
   |
5  |     let paths = vec![
   |         ----- binding `paths` declared here
...
11 |     do_something(&paths.iter().map(|path| path.as_path()).collect::<Vec<_>>());
   |                   ^^^^^                   -------------- returning this value requires that `paths` is borrowed for `'static`
   |                   |
   |                   borrowed value does not live long enough
12 | }
   | - `paths` dropped here while still borrowed

error[E0716]: temporary value dropped while borrowed
  --> src\main.rs:11:19
   |
11 |     do_something(&paths.iter().map(|path| path.as_path()).collect::<Vec<_>>());
   |     --------------^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-- temporary value is freed at the end of this statement
   |     |             |
   |     |             creates a temporary value which is freed while still in use
   |     argument requires that borrow lasts for `'static`

问题根源 #

1. 'static生命周期要求被引用的数据必须存活至程序结束，但main中的paths是局部变量，会在main函数执行完毕后销毁，无法满足'static要求。
2. collect::<Vec<_>>()生成的是临时Vec，该临时变量会在当前语句结束后立即被销毁，其引用自然无法拥有'static生命周期。
3. 多线程/异步任务可能在main中的paths销毁后仍在运行，若传递引用会导致悬垂引用，Rust的所有权系统会直接阻止这种不安全行为。

解决方案 #

方案1：传递所有权（推荐） #

将函数参数改为拥有所有权的Vec<PathBuf>，让线程/异步任务获取每个路径的所有权，彻底摆脱生命周期依赖。

修改后的代码：

use std::path::PathBuf;
use std::thread;

fn main() {
    let paths = vec![
        PathBuf::from("/path/to/file.txt"),
        PathBuf::from("/path/to/file2.txt"),
    ];

    // 如果main后续还要使用原paths，就传递clone后的副本
    do_something(paths.clone());

    // 继续使用原paths执行其他操作
}

fn do_something(paths: Vec<PathBuf>) {
    // 为每个路径生成线程，通过move转移所有权
    for path in paths {
        thread::spawn(move || {
            println!("处理文件: {:?}", path);
            // 在这里执行文件操作，比如读取、修改等
        });
    }
}

方案2：使用全局静态变量（不推荐） #

如果必须使用引用，可以将路径列表声明为全局静态变量，使其拥有'static生命周期，但这种方式会导致数据无法被正常回收，可能造成内存泄漏，仅适用于特殊场景。

示例代码：

use std::path::{Path, PathBuf};
use std::thread;

// 全局静态路径列表
static PATHS: &[&Path] = &[
    Path::new("/path/to/file.txt"),
    Path::new("/path/to/file2.txt"),
];

fn main() {
    do_something(PATHS);
}

fn do_something(paths: &'static [&Path]) {
    for &path in paths {
        thread::spawn(move || {
            println!("处理文件: {:?}", path);
        });
    }
}

异步场景适配 #

如果是异步函数（比如使用Tokio），同样推荐传递所有权的方式，确保异步任务持有数据的所有权，避免生命周期问题：

use std::path::PathBuf;
use tokio;

#[tokio::main]
async fn main() {
    let paths = vec![
        PathBuf::from("/path/to/file.txt"),
        PathBuf::from("/path/to/file2.txt"),
    ];

    do_something(paths.clone()).await;
}

async fn do_something(paths: Vec<PathBuf>) {
    let mut tasks = Vec::new();
    for path in paths {
        let task = tokio::spawn(async move {
            println!("异步处理文件: {:?}", path);
            // 执行异步文件操作
        });
        tasks.push(task);
    }

    // 等待所有任务完成
    for task in tasks {
        task.await.unwrap();
    }
}

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