multithreading - 为什么这个变量定义意味着静态生命周期？

Question

我正在尝试对向量 block 执行一个函数，然后使用消息传递库将结果发回。

但是，我收到一个关于向量生命周期的奇怪错误，它甚至没有参与线程操作:

src/lib.rs:153:27: 154:25 error: borrowed value does not live long enough
src/lib.rs:153   let extended_segments = (segment_size..max_val)
error: src/lib.rs:154     .collect::<Vec<_>>()borrowed value does not live long enough

note: reference must be valid for the static lifetime...:153
  let extended_segments = (segment_size..max_val)
src/lib.rs:153:3: 155:27: 154     .collect::<Vec<_>>()
note: but borrowed value is only valid for the statement at 153:2:
reference must be valid for the static lifetime...
src/lib.rs:
let extended_segments = (segment_size..max_val)
consider using a `let` binding to increase its lifetime

我尝试在迭代器周围移动并将生命周期添加到不同的地方，但我无法让检查器通过并且仍然停留在类型上。

违规代码如下，基于 concurrency chapter in the Rust book . (完整代码位于 github 。)

use std::sync::mpsc;
use std::thread;

fn sieve_segment(a: &[usize], b: &[usize]) -> Vec<usize> {
    vec![]
}
fn eratosthenes_sieve(val: usize) -> Vec<usize> {
    vec![]
}

pub fn segmented_sieve_parallel(max_val: usize, mut segment_size: usize) -> Vec<usize> {
    if max_val <= ((2 as i64).pow(16) as usize) {
        // early return if the highest value is small enough (empirical)
        return eratosthenes_sieve(max_val);
    }

    if segment_size > ((max_val as f64).sqrt() as usize) {
        segment_size = (max_val as f64).sqrt() as usize;
        println!("Segment size is larger than √{}. Reducing to {} to keep resource use down.",
                 max_val,
                 segment_size);
    }

    let small_primes = eratosthenes_sieve((max_val as f64).sqrt() as usize);
    let mut big_primes = small_primes.clone();

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

    let extended_segments = (segment_size..max_val)
        .collect::<Vec<_>>()
        .chunks(segment_size);
    for this_segment in extended_segments.clone() {
        let small_primes = small_primes.clone();
        let tx = tx.clone();

        thread::spawn(move || {
            let sieved_segment = sieve_segment(&small_primes, this_segment);
            tx.send(sieved_segment).unwrap();
        });
    }

    for _ in 1..extended_segments.count() {
        big_primes.extend(&rx.recv().unwrap());
    }

    big_primes
}

fn main() {}

我如何理解和避免此错误？我不确定如何使线程关闭的生命周期 static as in this question并且仍然具有可重用的功能(即，不是 main())。我不确定如何“消费所有进入 [闭包] 的东西”，如 this question 中所述。 .而且我不确定去哪里 insert .map(|s| s.into())以确保所有引用都成为移动，我也不确定我想要。

Answer 1

当尝试重现问题时，我鼓励您创建一个 MCVE通过删除所有不相关的代码。在这种情况下，类似这样的事情似乎会产生相同的错误:

fn segmented_sieve_parallel(max_val: usize, segment_size: usize) {
    let foo = (segment_size..max_val)
        .collect::<Vec<_>>()
        .chunks(segment_size);
}

fn main() {}

让我们分解一下:

1. 在数字之间创建一个迭代器。
2. 将它们全部收集到 Vec<usize> 中.
3. 返回一个包含对向量的引用的迭代器。
4. 由于向量未绑定(bind)到任何变量，因此它在语句末尾被删除。这会使迭代器指向无效的内存区域，因此这是不允许的。

查看 slice::chunks 的定义:

fn chunks(&self, size: usize) -> Chunks<T>

pub struct Chunks<'a, T> where T: 'a {
    // some fields omitted
}

生命周期标记 'a让您知道迭代器包含对某物的引用。 Lifetime elision 删除了 'a从函数中扩展如下:

fn chunks<'a>(&'a self, size: usize) -> Chunks<'a, T>

检查错误消息的这一行:

help: consider using a let binding to increase its lifetime

您可以这样操作:

fn segmented_sieve_parallel(max_val: usize, segment_size: usize) {
    let foo = (segment_size..max_val)
        .collect::<Vec<_>>();
    let bar = foo.chunks(segment_size);
}

fn main() {}

虽然我会把它写成

fn segmented_sieve_parallel(max_val: usize, segment_size: usize) {
    let foo: Vec<_> = (segment_size..max_val).collect();
    let bar = foo.chunks(segment_size);
}

fn main() {}

将此代码重新插入到您原来的问题中并不能解决问题，但它会更容易理解。那是因为您正试图传递对 thread::spawn 的引用，它可能比当前线程长寿。因此，一切都传递给了 thread::spawn必须有 'static生命周期。有大量问题详细说明了为什么必须阻止这种情况以及一连串的解决方案，包括作用域线程和克隆向量。

克隆载体是最简单的，但可能效率低下:

for this_segment in extended_segments.clone() {
    let this_segment = this_segment.to_vec();
    // ...
}