在Rust的子執行緒中使用主執行緒中定義的變數的正確方法是什么？

我是 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

我不太明白這里的錯誤資訊。但我想這是因為我latency_pairs在checker執行緒中使用并且latency_pairs在checker仍在執行時可能會被洗掉。我的理解正確嗎？如何修復錯誤？我試圖for (i, latency_pair) in latency_pairs.clone().iter().enumerate() {為執行緒傳遞一個克隆值，但它沒有幫助。

uj5u.com熱心網友回復：

latency_pairs保存參考latency，然后參考其中的參考matches。因此，克隆latency_pairs只是將參考克隆到latency和 中matches。

您的代碼將需要latency的型別&'static str，但它實際上是&'a str在那里'a，勢必matches'壽命。

你可以叫to_owned()上latency得到一個擁有價值和分割封閉字串里面也可以叫to_owned()上各自收集到的分裂的latency_pairs并移動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);

標籤：多线程 锈 所有权

上一篇：將字串發送到另一個python執行緒

下一篇：當另一個行程正在運行時，OpenMP非常慢