multithreading - How to multi-thread function calls on read-only data without cloning it? -

this question has answer here:

• lifetime of variables passed new thread 1 answer

take simple example we're using immutable list of vectors calculate new values.

given working, single threaded example:

use std::collections::linkedlist;  fn calculate_vec(v: &vec<i32>) -> i32 {     let mut result: i32 = 0;     in v {         result += *i;     }     return result; }  fn calculate_from_list(list: &linkedlist<vec<i32>>) -> linkedlist<i32> {     let mut result: linkedlist<i32> = linkedlist::new();     v in list {         result.push_back(calculate_vec(v));     }     return result; }  fn main() {     let mut list: linkedlist<vec<i32>> = linkedlist::new();     // arbitrary values     list.push_back(vec![0, -2, 3]);     list.push_back(vec![3, -4, 3]);     list.push_back(vec![7, -10, 6]);      let result = calculate_from_list(&list);     println!("here's result!");     in result {         println!("{}", i);     } } 

assuming calculate_vec processor intensive function, may want use multiple threads run this, following example works requires (what think is) unnecessary vector clone.

use std::collections::linkedlist;  fn calculate_vec(v: &vec<i32>) -> i32 {     let mut result: i32 = 0;     in v {         result += *i;     }     return result; }  fn calculate_from_list(list: &linkedlist<vec<i32>>) -> linkedlist<i32> {     use std::thread;     let mut result: linkedlist<i32> = linkedlist::new();     let mut join_handles = linkedlist::new();     v in list {         let v_clone = v.clone(); // <-- how avoid clone?         join_handles.push_back(thread::spawn(move || calculate_vec(&v_clone)));     }     j in join_handles {         result.push_back(j.join().unwrap());     }     return result; }  fn main() {     let mut list: linkedlist<vec<i32>> = linkedlist::new();     // arbitrary values     list.push_back(vec![0, -2, 3]);     list.push_back(vec![3, -4, 3]);     list.push_back(vec![7, -10, 6]);      let result = calculate_from_list(&list);     println!("here's result!");     in result {         println!("{}", i);     } } 

this example works, when vector cloned, logically, don't think should needed since vector immutable.

there no reason each call calculate_vec should need allocate new vector.

how simple example multi-threaded without needing clone data before passed closure?

---

update, heres working example uses arc based on @ker's suggestion, although need take ownership.

---

note 1) i'm aware there 3rd party libraries handle threading, interested know if possible using rust's standard library.

note 2) there quite few similar questions on threading examples involves threads writing data, isn't case here.

there multiple ways solve problem.

1. move vector arc<linkedlist<vec<i32>>> , clone that. after calculation, can use try_unwrap linkedlist<vec<i32>> back. works rust standard library.
   
   heres working example uses arc, though linkedlist replaced vec allow indexing.
   also note function needs own argument being passed in case.

2. use crossbeam crate create threads can reference scope, freeing need join_handles code hand. have minimal impact on code, since work want.

   crossbeam::scope(|scope| {     v in list {         scope.spawn(|| calculate_vec(&v))     } }); 

3. use scoped_threadpool crate. works crossbeam doesn't create 1 thread per task, instead spreads out tasks on limited number of threads. (thanks @delnan)

4. use rayon crate direct data parallelism

   use rayon::prelude::*; list.par_iter().map(|v| calculate_vec(&v)).collect()