Rust并发场景下借用数据逃逸函数的解决方法

问题背景 #

我正在学习Rust官方书籍，完成第12章的IO项目后，想通过并发优化程序——将目标文件分块，分配给不同线程处理匹配逻辑。但编写的并发代码出现了生命周期逃逸错误，目前只能通过为每个线程复制分块内容解决，但处理10万+行时性能下降明显。

当前代码 #

pub fn run(config: Config, content_per_thread: Vec<&str>) -> Result<(), Box<dyn Error>> {
    let (sender, receiver) = channel::<Vec<&str>>();
    concurrent_search(&config, content_per_thread, &sender);
    drop(sender);

    for v in receiver.iter() {
        v.iter().for_each(|line| println!("{:?}", line))
    }

    Ok(())
}

fn concurrent_search(config: &Config, content_per_thread: Vec<&str>, sender: &Sender<Vec<&str>>) {
    for i in 0..content_per_thread.len() {
        let th_query = config.query.clone();
        let th_sender = sender.clone();
        let th_content = content_per_thread[i].clone();

        thread::spawn(move || {
            let matched_lines = search(&th_query, th_content, true);
            th_sender.send(matched_lines.clone()).unwrap();
        });
    }
}

编译错误 #

error[E0521]: borrowed data escapes outside of function
  --> src/lib.rs:27:9
   |
21 |   fn concurrent_search(config: &Config, content_per_thread: Vec<&str>, sender: &Sender<Vec<&str>>) {
   |                                         ------------------      - let's call the lifetime of this reference `'1`
   |                                         |
   |                                         `content_per_thread` is a reference that is only valid in the function body
...
27 | /         thread::spawn(move || {
28 | |             let matched_lines = search(&th_query, th_content, true);
29 | |             th_sender.send(matched_lines.clone()).unwrap();
30 | |         });
   | |          ^
   | |          |
   | |__________`content_per_thread` escapes the function body here
   |            argument requires that `'1` must outlive `'static`

error[E0521]: borrowed data escapes outside of function
  --> src/lib.rs:27:9
   |
21 |   fn concurrent_search(config: &Config, content_per_thread: Vec<&str>, sender: &Sender<Vec<&str>>) {
   |                                                                        ------              - let's call the lifetime of this reference `'2`
   |                                                                        |
   |                                                                        `sender` is a reference that is only valid in the function body
...
27 | /         thread::spawn(move || {
28 | |             let matched_lines = search(&th_query, th_content, true);
29 | |             th_sender.send(matched_lines.clone()).unwrap();
30 | |         });
   | |          ^
   | |          |
   | |__________`sender` escapes the function body here
   |            argument requires that `'2` must outlive `'static`
   |
   = note: requirement occurs because of the type `Sender<Vec<&str>>`, which makes the generic argument `Vec<&str>` invariant
   = note: the struct `Sender<T>` is invariant over the parameter `T`

For more information about this error, try `rustc --explain E0521`.
error: could not compile `minigrep` due to 2 previous errors

最小复现示例 #

use std::sync::mpsc::{channel, Sender};
use std::thread;

pub fn main() {
    let content_per_thread = vec!["Hello\nGoodbye", "Wow\nCool\nData!", "a\nb\nc"];
    let (sender, receiver) = channel::<Vec<&str>>();
    concurrent_search("o", content_per_thread, &sender);
    drop(sender);

    for v in receiver.iter() {
        v.iter().for_each(|line| println!("{:?}", line))
    }
}

fn concurrent_search(query: &str, content_per_thread: Vec<&str>, sender: &Sender<Vec<&str>>) {
    for i in 0..content_per_thread.len() {
        let th_query = query.clone();
        let th_sender = sender.clone();
        let th_content = content_per_thread[i].clone();

        thread::spawn(move || {
            let matched_lines = search(&th_query, th_content);
            th_sender.send(matched_lines).unwrap();
        });
    }
}

fn search<'a>(query: &str, content: &'a str) -> Vec<&'a str> {
    content
        .lines()
        .filter(|line| line.contains(query))
        .collect()
}

错误原因分析 #

thread::spawn要求闭包捕获的变量必须满足'static生命周期——因为线程的执行时长不受当前函数控制，Rust无法保证函数内的引用在线程运行期间依然有效。代码中的核心问题：

1. content_per_thread里的&str是借用的，生命周期仅局限于concurrent_search函数，线程无法持有这类引用。
2. 传递给线程的是Sender的引用，同样不满足'static要求，克隆引用本质还是借用。

优化方案（无内容复制） #

1. 用Arc<String>共享分块内容 #

Arc是原子引用计数的智能指针，允许多个线程共享同一份数据的所有权，且仅复制指针和计数（开销极小），无需复制底层字符串。

2. 直接传递Sender所有权 #

mpsc::Sender本身可克隆且线程安全，无需传递引用，直接克隆Sender并转移所有权到线程闭包即可。

3. 持有String类型的查询 #

将查询从&str转换为String，让线程拥有查询的所有权，彻底规避生命周期限制。

修改后的最小复现代码 #

use std::sync::{Arc, mpsc::{channel, Sender}};
use std::thread;

pub fn main() {
    // 将分块内容包装成Arc<String>
    let content_per_thread = vec![
        Arc::new("Hello\nGoodbye".to_string()),
        Arc::new("Wow\nCool\nData!".to_string()),
        Arc::new("a\nb\nc".to_string()),
    ];
    let (sender, receiver) = channel::<Vec<String>>();
    // 传递String类型的query，以及Sender的所有权（克隆后）
    concurrent_search("o".to_string(), content_per_thread, sender.clone());
    drop(sender);

    for v in receiver.iter() {
        v.iter().for_each(|line| println!("{:?}", line))
    }
}

fn concurrent_search(query: String, content_per_thread: Vec<Arc<String>>, sender: Sender<Vec<String>>) {
    for content in content_per_thread {
        // 克隆Arc、query和Sender，转移到线程
        let th_query = query.clone();
        let th_sender = sender.clone();
        let th_content = content.clone();

        thread::spawn(move || {
            let matched_lines = search(&th_query, &*th_content);
            // 把匹配到的&str转换成String，避免返回引用的生命周期问题
            let matched_strings = matched_lines.into_iter().map(|s| s.to_string()).collect();
            th_sender.send(matched_strings).unwrap();
        });
    }
}

fn search(query: &str, content: &str) -> Vec<&str> {
    content
        .lines()
        .filter(|line| line.contains(query))
        .collect()
}

原项目调整建议 #

• 读取文件内容后，将分块的&str替换为Arc<String>，确保线程可安全共享。
• 将Config中的query改为String类型，或在传递给线程前克隆为String。
• 通道传递的结果从Vec<&str>改为Vec<String>，避免引用生命周期限制；也可在搜索时直接收集String，减少后续转换步骤。

内容的提问来源于stack exchange，提问作者João Victor Souza Lucena