Question

我有一个巨大的矢量，我希望能够并行加载/操作，例如在一个线程中加载前十万个索引，在另一个线程中加载，依此类推。由于这将成为代码中非常热门的一部分，我已经提出了以下概念验证不安全代码，以便在没有Arcs和Mutexes的情况下执行此操作：

let mut data:Vec<u32> = vec![1u32, 2, 3];
let head = data.as_mut_ptr();
let mut guards = (0..3).map(|i|
  unsafe {
    let mut target = std::ptr::Unique::new(head.offset(i));
    let guard = spawn(move || {
      std::ptr::write(target.get_mut(), 10 + i as u32);
    });
    guard
  });

我在这里错过了什么可以让这可能爆发？

这使用#![feature(unique)]所以我不知道如何在稳定中使用它。有没有办法在稳定中做这种事情（理想情况下安全，不使用原始指针和Arc和Mutex的开销）？

另外，查看documentation for Unique，它说

它还暗示如果没有Unique引用的唯一路径
，则不应修改指针的引用对象

我不清楚“独特路径”是什么意思。

Answer 1

如今，rayon板条箱已成为这类事情的事实上的标准：

use rayon::prelude::*;

fn main() {
    let mut data = vec![1, 2, 3];
    data.par_iter_mut()
        .enumerate()
        .for_each(|(i, x)| *x = 10 + i as u32);
    assert_eq!(vec![10, 11, 12], data);
}

请注意，这与使用标准迭代器的单线程版本仅有一行不同，后者将par_iter_mut替换为iter_mut。

另请参见Writing a small ray tracer in Rust and Zig。

Answer 2

可以使用外部库，例如simple_parallel（免责声明，我写过）允许一个人写：

extern crate simple_parallel;

let mut data = vec![1u32, 2, 3, 4, 5];

let mut pool = simple_parallel::Pool::new(4);

pool.for_(data.chunks_mut(3), |target| {
    // do stuff with `target`
})

chunks和chunks_mut方法是将T的向量/切片拆分为相同大小的块的完美方法：它们分别在{{1}类型的元素上返回迭代器}和&[T]。

并行处理vec：如何安全地进行，或者不使用不稳定的功能？

2 个答案: