Rust中如何传递带可变参数的函数用于并行碰撞检测？

我正在研究碰撞检测，编写了一个让两组对象相互碰撞的函数。为实现并行执行，仅将第一组设为可变，并使用rayon遍历其元素。目前一切正常，但我希望传入一个碰撞解析函数——由于该函数的第一个参数是可变引用，Rust要求函数本身为FnMut类型，这导致并行执行时出错。

相关代码如下：

pub fn collide_with_binned_static<T1: Send + Sync, T2: Send + Sync>(
    items_a: &mut [T1],
    aabb: impl Fn(&T1) -> Rect + Send + Sync,
    items_b: &[T2],
    bin_index_b: &BinIndex,
    f: impl FnMut(&mut T1, &T2) + Send + Sync)
{
    items_a.par_iter_mut().for_each(|item_a| {
        let collisions = bin_index_b.check_rect_collision(&aabb(item_a));
        for collision in collisions {
            f(&mut *item_a, &items_b[collision]);
//          ^ cannot borrow as mutable
        }
    });
}

报错信息为“cannot borrow as mutable”。我不理解为何接收可变参数的函数自身需要是可变的，若使用静态函数则可正常运行，请问该如何解决此问题？

先搞清楚报错核心原因 #

• 纠正一个误解：函数接收可变引用≠必须是FnMut类型。如果函数只是修改传入的参数，不触碰自身捕获的外部变量，那它可以是Fn类型。只有当闭包需要修改自己捕获的外部状态时，才会被编译器限定为FnMut。
• 这次报错的真正问题是：Rayon并行遍历要求闭包能安全跨线程共享，但FnMut的特性是——同一个FnMut实例不能被多个线程同时调用（调用它需要可变借用这个实例本身，而Rust不允许多线程同时持有可变借用）。你试图在所有并行任务里共享同一个FnMut闭包，这就触发了编译错误。

两种可行解决思路 #

1. 使用Fn类型（无状态处理场景）

如果你的碰撞解析逻辑不需要修改任何外部状态，只是单纯修改传入的T1对象，直接把f的类型从FnMut改成Fn即可。这样编译器会允许并行调用，因为Fn允许共享不可变借用，符合Sync要求。

修改后的函数签名：

pub fn collide_with_binned_static<T1: Send + Sync, T2: Send + Sync>(
    items_a: &mut [T1],
    aabb: impl Fn(&T1) -> Rect + Send + Sync,
    items_b: &[T2],
    bin_index_b: &BinIndex,
    f: impl Fn(&mut T1, &T2) + Send + Sync) // 替换FnMut为Fn
{
    items_a.par_iter_mut().for_each(|item_a| {
        let collisions = bin_index_b.check_rect_collision(&aabb(item_a));
        for collision in collisions {
            f(&mut *item_a, &items_b[collision]);
        }
    });
}

这也是为什么你用静态函数能正常运行的原因——静态函数本身就是Fn类型，没有捕获任何外部状态，天然支持多线程共享调用。

2. 为每个线程分配独立的FnMut实例（有状态处理场景）

如果你的碰撞解析必须修改外部状态（比如统计总碰撞次数、累计某种数据），那不能共享同一个FnMut，得给每个并行任务单独生成一份闭包实例。可以用Rayon提供的for_each_with方法实现：

pub fn collide_with_binned_static<T1: Send + Sync, T2: Send + Sync, F: FnMut(&mut T1, &T2) + Clone + Send>(
    items_a: &mut [T1],
    aabb: impl Fn(&T1) -> Rect + Send + Sync,
    items_b: &[T2],
    bin_index_b: &BinIndex,
    f: F) // 要求F实现Clone和Send，不再需要Sync
{
    items_a.par_iter_mut().for_each_with(f.clone(), |f, item_a| {
        let collisions = bin_index_b.check_rect_collision(&aabb(item_a));
        for collision in collisions {
            f(&mut *item_a, &items_b[collision]);
        }
    });
}

• for_each_with会为每个线程传递一个f的克隆实例，这样每个线程都有自己的FnMut闭包，各自修改自己的状态，不会有共享可变借用的冲突。
• 这里需要F实现Clone，这样才能复制闭包；只需要Send不需要Sync，因为每个线程用自己的实例，不存在跨线程共享的情况。

额外补充：三个Fn trait的核心区别 #

• Fn：无状态，可多次调用，允许被多线程共享（满足Sync），适合纯逻辑处理。
• FnMut：有状态，可多次调用，但调用时需要可变借用自身，不能被多线程同时调用（除非内部状态是线程安全的，比如用Mutex包裹）。
• FnOnce：只能调用一次，会消耗自身，完全不适合并行遍历场景。

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