Lifetime issues during recursive calls - multithreading

Question

I am trying to implement a BFS algorithm to check whether a graph is a tree using Rust. I am an absolute beginner in Rust and I am confused with lifetime specification when it comes to threads. My code currently looks like this:
The graph is passed as adjacency matrix named adj_mat which is a vector of vectors. Nodes visited will be marked as true in the visited vector. And the parent vector stores the parent of each node visited. The function is_tree_parallel will call the bfs function, which will then spawn a new thread for each child of the current thread. This algorithm works fine when I use adj_mat, visited and parent vector as global variables.
fn is_tree_parallel(adj_mat: &Vec<Vec<usize>>, nodes: usize) {
let mut visited = vec![false; nodes + 1];
let mut parent = vec![0; nodes + 1];
let mut node_current = 1;
bfs(&mut parent, &adj_mat, &mut visited, node_current, nodes);
// Do checking of visited array and CYCLE (shared memory variable used to
// detect cycle) and decide whether it is a tree
}
When I use below function to spawn new threads, this is giving me errors like:
cannot infer an appropriate lifetime due to conflicting requirements first, the lifetime cannot outlive the expression.
I understand that this is due to the recursive calls inside the bfs function.
fn bfs(mut parent: &mut Vec<usize>, adj_mat: &Vec<Vec<usize>>, mut visited: &mut Vec<bool>, mut currentnode: usize, nodes: usize) {
visited[currentnode as usize] = true;
for i in 0..nodes {
if adj_mat[currentnode - 1][i as usize] == 1 && (i + 1) != parent[currentnode] {
if visited[i + 1 ] {
CYCLE = true;
return;
} else {
if RUNTHREADS < NTHREADS { //RUNTHREADS and NTHREADS will limit the number of threads spawned
RUNTHREADS += 1;
let mut visited = Arc::new(Mutex::new(visited));
let mut parent = Arc::new(Mutex::new(parent));
let adj_mat = Arc::new(adj_mat);
let visited = visited.clone();
let parent = parent.clone();
let adj_mat = adj_mat.clone();
thread::spawn(move || {
let visited = visited.lock().unwrap();
let parent = parent.lock().unwrap();
bfs(&mut parent, &adj_mat, &mut visited, i, nodes);
}).join();
} else {
bfs(parent, adj_mat, visited, i, nodes);
}
}
}
}
}
The error that I receive:
src/main.rs:134:69: 134:76 error: cannot infer an appropriate lifetime due to conflicting requirements [E0495]
src/main.rs:134 let mut visited = Arc::new(Mutex::new(visited));
src/main.rs:134:49: 134:57 note: first, the lifetime cannot outlive the expression at 134:48...
src/main.rs:134 let mut visited = Arc::new(Mutex::new(visited));
src/main.rs:134:49: 134:57 note: ...so that a type/lifetime parameter is in scope here
src/main.rs:134 let mut visited = Arc::new(Mutex::new(visited));
src/main.rs:134:49: 134:78 note: but, the lifetime must be valid for the call at 134:48...
src/main.rs:134 let mut visited = Arc::new(Mutex::new(visited));
src/main.rs:134:58: 134:77 note: ...so that argument is valid for the call
src/main.rs:134 let mut visited = Arc::new(Mutex::new(visited));
Am I doing it correct? How can I correct them? Is there any other way to achieve these recursive calls using threads?