Multithreading 如何在Arc上使用std:：slice:：Chunks<；互斥锁<；Vec<；u8>&燃气轮机&燃气轮机；螺纹之间是否有适当的锈蚀？

我想了解一下为什么在生锈的情况下，下面的代码似乎不能正常工作

我想分块一个向量，给每个线程一个块来处理它。我试着用一个Arc和一个互斥组合来相互访问我的vec

这是我第一次（显然）尝试： 声明vec，将其分块，并将分块发送到每个线程。在我的理解中，它应该是有效的，因为Chunk方法保证了不重叠的Chunk

use std::sync::{Arc, Mutex};
use std::thread;

fn main() {
    let data = Arc::new(Mutex::new(vec![0;20]));
    let chunk_size = 5;
    let mut threads = vec![];
    let chunks: Vec<&mut [u8]> = data.lock().unwrap().chunks_mut(chunk_size).collect();

    for chunk in chunks.into_iter(){
        threads.push(thread::spawn(move || {
                inside_thread(chunk)
            }));
    }

}
fn inside_thread(chunk: &mut [u8]) {
    // now do something with chunk
}

错误仍然表明数据不够活跃

下一次尝试也没有成功。我想我可以绕过它，把它分块到线程中，然后通过索引得到我的分块。但如果它起作用，代码就不会非常地道：/

use std::sync::{Arc, Mutex};
use std::thread;

fn main() {
    let data = Arc::new(Mutex::new(vec![0;20]));
    let chunk_size = 5;
    let mut threads = vec![];

    for i in 0..data.lock().unwrap().len() / chunk_size {
        let ref_to_data = data.clone();
        threads.push(thread::spawn(move || {
                inside_thread(ref_to_data, i, chunk_size)
            }));
    }

}
fn inside_thread(data: Arc<Mutex<Vec<u8>>>, index: usize, chunk_size: usize) {
    let chunk: &mut [u8] = data.lock().unwrap().chunks_mut(chunk_size).collect()[index];
    // now do something with chunk
}

使用std:：sync:：{Arc，Mutex}；
使用std：：线程；
fn main（）{
让data=Arc:：new（Mutex:：new（vec！[0；20]）；
让chunk_size=5；
让mut threads=vec！[]；
对于0中的i..data.lock（）.unwrap（）.len（）/chunk\u size{
让ref_to_data=data.clone（）；
threads.push（线程：：spawn（移动| |）{
内部线程（参考到数据，i，块大小）
}));
}
}
fn内螺纹（数据：圆弧，索引：usize，块大小：usize）{
let chunk:&mut[u8]=data.lock（）.unwrap（）.chunk_mut（chunk_size.collect（）[index]；
//现在用chunk做点什么
}

错误显示：

--> src/main.rs:18:72
   |
18 |     let chunk: &mut [u8] = data.lock().unwrap().chunks_mut(chunk_size).collect()[index];
   |                                                                        ^^^^^^^
   |                                                                        |
   |                                                                        cannot infer type for type parameter `B` declared on the method `collect`
   |                                                                        help: consider specifying the type argument in the method call: `collect::<B>`
   |
   = note: type must be known at this point

-->src/main.rs:18:72
|
18 | let chunk:&mut[u8]=data.lock（）.unwrap（）.chunk_mut（chunk_size.collect（）[index]；
|                                                                        ^^^^^^^
|                                                                        |
|无法为方法“collect”上声明的类型参数“B”推断类型`
帮助：考虑在方法调用中指定类型参数：
|
=注意：此时必须知道类型

当我试图推断它时，它也不起作用。所以现在我尝试了很多，但都没有成功，我失去了主意。 好吧，我总是能做的就是“自己做分块”。只需在线程内对向量进行变异就可以了。但在我看来，这并不是一个惯用的好方法

问题：有没有一种可能的方法解决这个问题？

提示：我知道我可以使用作用域线程池或类似的东西，但我想为我的论文获得这些知识

---

非常感谢您在这方面花费时间

您正试图收集到某个内容，然后将其索引到其中。我猜不出那是什么东西。但是，当您只需要一个值时，收集到向量中是一种浪费。您可以改为使用

let chunk:&mut[u8]=data.lock（）.unwrap（）.chunks_mut（chunk_size）.nth（index.unwrap（）只拿一个你需要的。嗨，彼得！我像你一样做了，但是当我尝试改变vec时，它仍然显示一个错误：“创建一个在使用中被释放的临时文件”，你需要写一个，它清楚地显示了你试图解决的（单个）问题。
--> src/main.rs:18:72
   |
18 |     let chunk: &mut [u8] = data.lock().unwrap().chunks_mut(chunk_size).collect()[index];
   |                                                                        ^^^^^^^
   |                                                                        |
   |                                                                        cannot infer type for type parameter `B` declared on the method `collect`
   |                                                                        help: consider specifying the type argument in the method call: `collect::<B>`
   |
   = note: type must be known at this point