Rust 读取派生线程内的不可变值

我正在努力使这个例子起作用

use std::sync::mpsc::{Sender, Receiver};
use std::sync::mpsc;
use std::thread;
use std::sync::Arc;

struct User {
    reference: String,
    email: String
}

struct UserIndex {
    reference: usize,
    email: usize
}

fn main() {

    let rows = vec![
        vec!["abcd", "test@test.com"],
        vec!["efgh", "test1@test.com"],
        vec!["wfee", "test2@test.com"],
        vec!["rrgr", "test3@test.com"]
    ];

    let user_index = Arc::new(
        UserIndex {
            reference: 0,
            email: 1
        }
    );

    let chunk_len = (rows.len() / 2) as usize;
    let mut chunks = Vec::new();
    for chunk in rows.chunks(chunk_len) {
        chunks.push(chunk.to_owned());
    }

    let (tx, rx): (Sender<Vec<User>>, Receiver<Vec<User>>) = mpsc::channel();

    for chunk in chunks {
        let thread_tx = tx.clone();
        thread::spawn(move || {
            let user_index_cloned = user_index.clone();
            let result = chunk.iter().map( |row|
                User {
                    reference: row[user_index_cloned.reference].to_string(),
                    email: row[user_index_cloned.email].to_string()
                }
            ).collect::<Vec<User>>();
            thread_tx.send(result).unwrap();
        });
    }

    let mut users = Vec::new();
    for _ in 0..chunk_len {
        users.push(rx.recv());
    }

}

---

现在，据我所知，它本应该起作用的，但它不起作用。我在这里错过了什么？

你就快到了。只是

Arc

必须在生成的线程之外进行克隆：

for chunk in chunks {
    let thread_tx = tx.clone();
    let user_index_cloned = user_index.clone();
    thread::spawn(move || {
        let result = chunk.iter().map( |row|
            User {
                reference: row[user_index_cloned.reference].to_string(),
                email: row[user_index_cloned.email].to_string()
            }
        ).collect::<Vec<User>>();
        thread_tx.send(result).unwrap();
    });
}

用于块中的块{
让线程_tx=tx.clone（）；
让user_index_clone=user_index.clone（）；
线程：：生成（移动| |{
让结果=chunk.iter（）.map（|行|
使用者{
引用：行[user\u index\u cloned.reference].to\u string（），
电子邮件：行[user\u index\u cloned.email].to\u string（）
}
)收集：：（）；
线程发送（结果）.unwrap（）；
});
}

必须这样做，否则

user\u index

确实会被移动到线程中，在循环中这样做违反了所有权规则

for chunk in chunks {
    let thread_tx = tx.clone();
    let user_index_cloned = user_index.clone();
    thread::spawn(move || {
        let result = chunk.iter().map( |row|
            User {
                reference: row[user_index_cloned.reference].to_string(),
                email: row[user_index_cloned.email].to_string()
            }
        ).collect::<Vec<User>>();
        thread_tx.send(result).unwrap();
    });
}