thread::scope() 变量和衍生线程的生命周期

Question

我正在尝试对值列表进行一些并行处理：

fn process_list(list: Vec<f32>) -> Vec<f32> { // Block F
    let chunk_size = 100;
    let output_list = vec![0.0f32;list.len()];

    thread::scope(|s| { // Block S
        (0..list.len()).collect::<Vec<_>>().chunks(chunk_size).for_each(|chunk| { // Block T
            s.spawn(|| {
                chunk.into_iter().for_each(|&idx| {
                    let value = calc_value(list[idx]);
                    unsafe {
                        let out = (output_list.as_ptr() as *mut f32).offset(idx as isize);
                        *out = value;
                    }
                });
            });
        });
    });
    output_list
}

API 表示thread::scope()仅在它创建的 scope 生成的每个线程完成后返回。 然而，编译器告诉我临时范围 object (0..list.len())被解构，而使用它的线程可能仍然存在。

我很好奇引擎盖下到底发生了什么。 我的直觉告诉我，在 Block S 中生成的每个线程和创建的变量都具有 Block S 的生命周期。 但显然线程的生命周期比 Block S 长。

为什么这些生命周期不一样？

此处的最佳做法是在 Block F 中创建一个变量，该变量用于临时目的，如下所示：

fn process_list(list: Vec<f32>) -> Vec<f32> { // Block F
    let chunk_size = 100;
    let output_list = vec![0.0f32;list.len()];
    let range = (0..list.len()).collect::<Vec<_>>();

    thread::scope(|s| { // Block S
        range.chunks(chunk_size).for_each(|chunk| { // Block T
            s.spawn(|| {
                chunk.into_iter().for_each(|&idx| {
                    let value = calc_value(list[idx]);
                    unsafe {
                        let out = (output_list.as_ptr() as *mut f32).offset(idx as isize);
                        *out = value;
                    }
                });
            });
        });
    });
    output_list
}

Answer 1

你不必问 SO 来了解std函数的幕后情况，它们的源代码很容易获得，但既然你问了，我会尝试在评论中解释更多。

 pub fn scope<'env, F, T>(f: F) -> T where F: for<'scope> FnOnce(&'scope Scope<'scope, 'env>) -> T, { // `Scope` creation not very relevant to the issue at hand let scope =...; // here your 'Block S' gets run and returns. let result = catch_unwind(AssertUnwindSafe(|| f(&scope))); // the above is just a fancy way of calling `f` while catching any panics. // but we're waiting for threads to finish running until here while scope.data.num_running_threads.load(Ordering::Acquire);= 0 { park(). } // further not so relevant cleanup code //... }

因此，正如您所看到的，只要任何线程出错，“Block S”就会一直存在。

---

是的，解决方案是在调用thread::scope之前捕获块的所有者。 对于您的示例，也没有理由深入研究unsafe ，您可以改用zip ：

fn process_list(list: Vec<f32>) -> Vec<f32> { // Block F
    let chunk_size = 100;
    let mut output_list = vec![0.0f32; list.len()];
    let mut zipped = list
        .into_iter()
        .zip(output_list.iter_mut())
        .collect::<Vec<_>>();

    thread::scope(|s| { // Block S
        zipped.chunks_mut(chunk_size).for_each(|chunk| { // Block T
            s.spawn(|| {
                chunk.into_iter().for_each(|(v, out)| {
                    let value = calc_value(*v);
                    **out = value;
                });
            });
        });
    });
    output_list
}