Lifetimes for threading with Arc [duplicate] - multithreading

Question

This question already has answers here:
The lifetime of self parameter in Rust when using threads [duplicate]
(1 answer)
How can I pass a reference to a stack variable to a thread?
(1 answer)
Closed 2 years ago.
I implemented a simple game of life and I want to try multithreading for the first time.
I use a 1D representation of the gamefield according to the formula index = y * height + x. Each cell is stored in a HashSet. A cell is alive if its contained in the set.
The relevant part of the code regarding the multithreading ([playground][1]):
extern crate crossbeam_utils; // 0.8.1
use std::collections::HashSet;
use std::sync::Arc;
use crossbeam_utils::thread;
pub struct GameOfLife {
width: u32,
height: u32,
live_cells: HashSet<u32>,
}
impl GameOfLife {
pub fn new(width: u32, height: u32) -> Self {
GameOfLife {
width,
height,
live_cells: HashSet::with_capacity((width * height / 2) as usize),
}
}
fn live_neighbours(&self, pos: u32) -> usize {
let indicies: [i64; 8] = [
pos as i64 - self.width as i64 - 1,
pos as i64 - self.width as i64,
pos as i64 - self.width as i64 + 1,
pos as i64 - 1,
pos as i64 + 1,
pos as i64 + self.width as i64 - 1,
pos as i64 + self.width as i64,
pos as i64 + self.width as i64 + 1,
];
indicies
.iter()
.filter(|&&i| {
i >= 0
&& i < (self.width * self.height) as i64
&& self.live_cells.contains(&(i as u32))
})
.count()
}
fn next_gen(&self, start: u32, stop: u32) -> HashSet<u32> {
(start..stop)
.into_iter()
.filter(
|&i| match (self.live_neighbours(i), self.live_cells.contains(&i)) {
(2, true) | (3, _) => true,
_ => false,
},
)
.collect::<HashSet<u32>>()
}
pub fn next_generation(&mut self) {
let size = self.width * self.height;
let half = (size / 2) as u32;
let mut new_cells = HashSet::<u32>::with_capacity(half as usize);
{
let h1 = thread::scope(|s| s.spawn(|_| self.next_gen(0, half))).unwrap();
let h2 = thread::scope(|s| s.spawn(|_| self.next_gen(half, size))).unwrap();
new_cells.extend(&h1.join().unwrap());
new_cells.extend(&h2.join().unwrap());
}
self.live_cells = new_cells;
}
}
fn main() {
let mut gol = GameOfLife::new(170, 40);
//seed random values ...
for _i in 0..1000000 {
gol.next_generation();
}
}
I am using the crate crossbeam_util="0.8".
I am now getting this error:
error: lifetime may not live long enough
--> src/main.rs:60:40
|
60 | let h1 = thread::scope(|s| s.spawn(|_| self.next_gen(0, half))).unwrap();
| -- ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ returning this value requires that `'1` must outlive `'2`
| ||
| |return type of closure is ScopedJoinHandle<'2, HashSet<u32>>
| has type `&'1 Scope<'_>`
Updated playground link: playground