Multithreading 如何使用Rust中的多个线程在struct方法中处理向量？

我有一个Rust中的结构，表示一个重数据数组的容器。我需要一种方法来对这些数据执行一些计算：

pub struct MultithreadTest {
    data: Vec<usize>,
}

impl MultithreadTest {
    const WORKERS_COUNT: usize = 2;

    pub fn new(data: Vec<usize>) -> Self {
        Self { data }
    }

    pub fn calculate(&self) {
        let data = std::sync::Arc::new(&self.data);

        let (tx, rx) = std::sync::mpsc::channel();

        (0..Self::WORKERS_COUNT).for_each(|thread_index| {
            let data = data.clone();
            let tx = tx.clone();

            std::thread::spawn(move || {
                // Do some stuff with data
                let sum: usize = data.iter().skip(thread_index).sum();

                tx.send(sum).unwrap();
            });
        });

        let result: usize = rx.iter().take(Self::WORKERS_COUNT).sum();

        println!("{:}", result);
    }
}

---

多亏了马斯克林的回答，我找到了一个使用横梁的工作示例：

pub struct MultithreadTest {
    data: Vec<usize>,
}

impl MultithreadTest {
    const WORKERS_COUNT: usize = 2;

    pub fn new(data: Vec<usize>) -> Self {
        Self { data }
    }

    pub fn calculate(&self) {
        crossbeam::scope(|scope| {
            let workers: Vec<_> = (0..Self::WORKERS_COUNT)
                .map(|thread_index| {
                    scope.spawn(move || {
                        // Do some stuff with data
                        let sum: usize = self.data.iter().skip(thread_index).sum();

                        sum
                    })
                })
                .collect();

            let result: usize = workers.into_iter().map(|w| w.join()).sum();
            println!("{:}", result);
        });
    }
}

pub结构多线程测试{
资料来源：Vec，
}
impl多线程测试{
施工工人数量：usize=2；
发布fn新（数据：Vec）->Self{
自{data}
}
发布fn计算（&self）{
横梁：：范围（|范围|{
let workers:Vec=（0..Self:：workers\u COUNT）
.map（|线程|索引|{
范围.繁殖（移动| |{
//用数据做一些事情
让sum:usize=self.data.iter（）.skip（thread_index.sum（）；
总和
})
})
.收集（）；
让结果：usize=workers.into_iter（）.map（|w | w.join（））.sum（）；
println！（“{：}”，结果）；
});
}
}

不清楚您想要实现什么，您只是想以多线程的方式执行计算，还是这更复杂？根本的问题是stdlib线程没有限定范围（而且您也没有加入它们），因此编译器无法知道

self

在线程的生命周期内是有效的，就其而言，线程的生命周期是无限的，因此可以使用

的静态

数据或拥有它所需的数据，借用是不可接受的，即使它们是线程安全的。现在一个解决方案是使用横梁的作用域线程（并正确地连接线程），这样您就可以借用该持续时间。然而，在这里的示例中，您可以使用Rayon的并行迭代器，执行此类操作/累加是它的主要任务。顺便说一句，请注意，在这里使用通道完全是过火了：生锈的线程可以返回值，即“线程所有者”检索值（或线程失败时的错误）从句柄上的

join

方法。通道用于有多个使用者或线程需要生成多个值的情况，这里不是这种情况。我只想对多个线程的

数据的不同部分进行一些繁重的计算。上面的示例非常简单。每个线程都应该参与其中对数据进行分类并进行计算（有时部分会重叠，因此我不能在许多
Vec
s部分上拆分
data
）.在实际任务中，
数据
甚至不是一个简单的
Vec
。我的问题是，我不知道如何告诉Rust，我真的确信
self
和其中的数据会比这些计算更有效。