Can you specify a non-static lifetime for threads? [duplicate] - multithreading

Question

This question already has answers here:
How can I pass a reference to a stack variable to a thread?
(1 answer)
Thread references require static lifetime?
(1 answer)
How do I use static lifetimes with threads?
(2 answers)
How can I send non-static data to a thread in Rust and is it needed in this example?
(1 answer)
Closed 3 years ago.
Here's a toy example of my problem:
use std::sync::{Arc, Mutex};
fn operate_in_chunks(vec: &mut Vec<f32>) {
let chunk_size = 10;
let mutex_vec: Arc<Mutex<&mut Vec<f32>>> = Arc::new(Mutex::new(vec));
let handles = Vec::new();
for chunk in 0..vec.len() / chunk_size {
handles.push(std::thread::spawn(move || {
operate(mutex_vec, chunk);
}));
}
for i in 0..handles.len() {
handles[i].join().unwrap();
}
}
fn operate(mutex_vec: Arc<Mutex<&mut Vec<f32>>>, chunk: usize) {}
I'd like to do some work on the passed-in struct, split among a number of threads, and then join them all back together before returning.
The error I get says:
error[E0621]: explicit lifetime required in the type of `vec`
--> src/lib.rs:10:22
|
3 | fn operate_in_chunks(vec: &mut Vec<f32>) {
| ------------- help: add explicit lifetime `'static` to the type of `vec`: `&'static mut std::vec::Vec<f32>`
...
10 | handles.push(std::thread::spawn(move || {
| ^^^^^^^^^^^^^^^^^^ lifetime `'static` required
I understand what it's complaining about: if the threads may have a 'static lifetime, and they reference vec, vec must have a 'static lifetime. However, my use-case should in theory be possible: I want to guarantee that the threads don't have a 'static lifetime, as they're all joined before the function returns, in which case I shouldn't need a 'static' lifetime onvec`.
Does Rust have a way of articulating this - unifying the lifetime of the threads with the lifetime of vec - or are all threads always 'static no matter what?

Answer 1

Rust actually used to allow scoped threads, which allow non-static lifetimes for any data passed. However, the API was found to be unsound and they were removed around two years ago. Fortunately, crossbeam, a crate, implements scoped threads with a different API allowing you to use this functionality safely. A sample from crossbeam's documentation is here:
let array = [1, 2, 3];
crossbeam::scope(|scope| {
for i in &array {
scope.spawn(move || {
println!("element: {}", i);
});
}
});