Rust使用Rayon实现目录遍历的并行递归错误修复求助

问题背景 #

刚接触Rust，尝试用Rayon实现并行递归目录遍历，编写了如下并行代码：

struct Node {
    path: PathBuf,
    files: Vec<PathBuf>,
    hashes: Vec<String>,
    folders: Vec<Box<Node>>,
}

impl Node {
    pub fn new(path: PathBuf) -> Self {
        Node {
            path: path,
            files: Vec::new(),
            hashes: Vec::new(),
            folders: Vec::new(),
        }
    }
    
    pub fn burrow(&mut self) {
        let mut contents: Vec<PathBuf> = ls_dir(&self.path);

        contents.par_iter().for_each(|item| 
                                if item.is_file() {
                                    self.files.push(*item);
                                } else if item.is_dir() {
                                    let mut new_folder = Node::new(*item);
                                    new_folder.burrow();
                                    self.folders.push(Box::new(new_folder));
                                });
        
    }
}

运行后出现以下编译错误：

error[E0596]: cannot borrow `*self.files` as mutable, as it is a captured variable in a `Fn` closure
  --> src/main.rs:40:37
   |
40 | ...                   self.files.push(*item);
   |                       ^^^^^^^^^^^^^^^^^^^^^^ cannot borrow as mutable

error[E0507]: cannot move out of `*item` which is behind a shared reference
  --> src/main.rs:40:53
   |
40 | ...                   self.files.push(*item);
   |                                       ^^^^^ move occurs because `*item` has type `PathBuf`, which does not implement the `Copy` trait

error[E0507]: cannot move out of `*item` which is behind a shared reference
  --> src/main.rs:42:68
   |
42 | ...                   let mut new_folder = Node::new(*item);
   |                                                      ^^^^^ move occurs because `*item` has type `PathBuf`, which does not implement the `Copy` trait

error[E0596]: cannot borrow `*self.folders` as mutable, as it is a captured variable in a `Fn` closure
  --> src/main.rs:44:37
   |
44 | ...                   self.folders.push(Box::new(new_folder));
   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ cannot borrow as mutable

已知这些错误是线程安全限制导致，但不知道如何修复，以下是功能正常的串行版本代码：

pub fn burrow(&mut self) {
    let mut contents: Vec<PathBuf> = ls_dir(&self.path);

    for item in contents {
        if item.is_file() {
            self.files.push(item);
        } else if item.is_dir() {
            let mut new_folder = Node::new(item);
            new_folder.burrow();
            self.folders.push(Box::new(new_folder));
        }
    }
}

错误分析与修复方案 #

1. 可变引用的线程安全问题 #

Rayon的par_iter().for_each要求闭包是Fn类型，不允许捕获可变引用——多线程同时修改self.files或self.folders会引发数据竞争，Rust所有权系统直接阻止了这种不安全操作。

正确思路是：先并行处理所有目录内容，将结果收集为独立的文件列表和文件夹节点列表，再一次性合并到self中，避免多线程直接修改同一可变对象。

2. PathBuf的移动问题 #

par_iter()生成的是共享引用（&PathBuf），无法直接移动*item。改用into_par_iter()直接消费contents的所有权，就能获取每个PathBuf的完整所有权，无需拷贝或克隆。

修复后的代码 #

use rayon::prelude::*;
use std::path::{Path, PathBuf};

struct Node {
    path: PathBuf,
    files: Vec<PathBuf>,
    hashes: Vec<String>,
    folders: Vec<Box<Node>>,
}

impl Node {
    pub fn new(path: PathBuf) -> Self {
        Node {
            path,
            files: Vec::new(),
            hashes: Vec::new(),
            folders: Vec::new(),
        }
    }
    
    pub fn burrow(&mut self) {
        let contents: Vec<PathBuf> = ls_dir(&self.path);

        // 并行处理所有目录内容，分离文件和文件夹节点
        let (files, folders): (Vec<PathBuf>, Vec<Box<Node>>) = contents
            .into_par_iter()
            .map(|item| {
                if item.is_file() {
                    Ok(item)
                } else if item.is_dir() {
                    let mut folder = Node::new(item);
                    folder.burrow();
                    Err(Box::new(folder))
                } else {
                    // 忽略非文件/目录项（如符号链接）
                    Ok(PathBuf::new())
                }
            })
            .partition(|res| res.is_ok());

        // 合并文件列表，过滤空PathBuf
        self.files.extend(files.into_iter().filter(|p| !p.is_empty()));
        // 合并文件夹节点
        self.folders.extend(folders.into_iter().map(|e| e.unwrap_err()));
    }
}

// 目录内容读取函数示例
fn ls_dir(path: &Path) -> Vec<PathBuf> {
    std::fs::read_dir(path)
        .unwrap()
        .filter_map(|entry| entry.ok().map(|e| e.path()))
        .collect()
}

关键修改说明 #

• into_par_iter()替代par_iter()：直接获取PathBuf所有权，解决移动问题。
• map+partition分离结果：并行处理每个条目，用Ok/Err分支区分文件和文件夹节点，最后拆分两个列表。
• 主线程合并结果：在单线程中把收集到的文件和文件夹节点合并到self，保证线程安全。

额外优化建议 #

• 符号链接处理：当前代码忽略符号链接，可根据需求添加跟随或记录逻辑。
• 错误处理：示例中ls_dir用unwrap()简化处理，实际项目应处理read_dir的权限、IO等错误。

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