在 Rust 的子線程中使用主線程中定義的變量的正確方法是什么？

Question

我是 Rust 的新手，仍在閱讀 Rust 書。 下面是我的程序。

use clap::{App, Arg};

type GenericError = Box<dyn std::error::Error + Send + Sync + 'static>;
type GenericResult<T> = Result<T, GenericError>;

fn main() -> GenericResult<()> {
    let matches = App::new("test")
        .arg(Arg::new("latency")
            .takes_value(true))
        .get_matches();


    let latency_present = matches.is_present("latency");
    let latency = matches.value_of("latency").unwrap_or("1000:10,300:30");
    let latency_pairs: Vec<&str> = latency.split(",").collect();

    let checker = std::thread::spawn(move || -> GenericResult<()>{
        loop {
            if latency_present {
                for (i, latency_pair) in latency_pairs.iter().enumerate() {
                    // let latency_pair: Vec<&str> = latency_pair.split(":").collect();
                    // let latency = latency_pair[0].parse::<f64>().unwrap();
                }
            }
        }
    });

    checker.join().unwrap()?;
    Ok(())
}

當我運行它時，它告訴我：

error[E0597]: `matches` does not live long enough
  --> src\main.rs:14:19
   |
14 |     let latency = matches.value_of("latency").unwrap_or("1000:10,300:30");
   |                   ^^^^^^^--------------------
   |                   |
   |                   borrowed value does not live long enough
   |                   argument requires that `matches` is borrowed for `'static`
...
30 | }
   | - `matches` dropped here while still borrowed

我不太明白這里的錯誤信息。 但我想這是因為我在checker線程中使用了latency_pairs ，並且在checker仍在執行時可能會丟棄latency_pairs 。 我的理解正確嗎？ 如何修復錯誤？ 我for (i, latency_pair) in latency_pairs.clone().iter().enumerate() {以便為線程傳遞一個克隆值，但它沒有幫助。

Answer 1

latency_pairs將引用保存到latency中，延遲又引用matches 。 因此克隆latency_pairs只是將引用克隆到latency和matches 。

您的代碼將要求latency的類型是&'static str但它實際上是&'a str其中'a綁定到matches ' 生命周期。

您可以在latency上調用to_owned()以獲取擁有的值並在閉包內拆分字符串，或者您可以在latency_pairs中收集的每個拆分上調用to_owned()並將該Vec<String>移動到閉包中：

    let latency_pairs: Vec<String> = latency.split(",").map(ToOwned::to_owned).collect();

    let checker = std::thread::spawn(move || -> GenericResult<()>{
        loop {
            if latency_present {
                for (i, latency_pair) in latency_pairs.iter().enumerate() {
                    // let latency_pair: Vec<&str> = latency_pair.split(":").collect();
                    // let latency = latency_pair[0].parse::<f64>().unwrap();
                }
            }
        }
    });

如果您需要在閉包之外使用latency_pairs ，您可以在將其移入閉包之前對其進行克隆：

    let latency_pairs: Vec<String> = latency.split(",").map(ToOwned::to_owned).collect();
    let latency_pairs_ = latency_pairs.clone();
    let checker = std::thread::spawn(move || -> GenericResult<()>{
        loop {
            if latency_present {
                for (i, latency_pair) in latency_pairs_.iter().enumerate() {
                    // let latency_pair: Vec<&str> = latency_pair.split(":").collect();
                    // let latency = latency_pair[0].parse::<f64>().unwrap();
                }
            }
        }
    });
    println!("{:?}", latency_pairs);