読み取り専用のデータを複製せずにマルチスレッド関数呼び出しを実行するには？

Question

新しい値を計算するためにベクトルの不変なリストを使用しているこの単純な例を考えてみましょう。 calculate_vecを想定し

use std::collections::LinkedList; 

fn calculate_vec(v: &Vec<i32>) -> i32 { 
    let mut result: i32 = 0; 
    for i in v { 
     result += *i; 
    } 
    return result; 
} 

fn calculate_from_list(list: &LinkedList<Vec<i32>>) -> LinkedList<i32> { 
    let mut result: LinkedList<i32> = LinkedList::new(); 
    for v in list { 
     result.push_back(calculate_vec(v)); 
    } 
    return result; 
} 

fn main() { 
    let mut list: LinkedList<Vec<i32>> = LinkedList::new(); 
    // some 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 the result!"); 
    for i in result { 
     println!("{}", i); 
    } 
} 

は、プロセッサ集約関数であり、我々はこれを実行するために、複数のスレッドを使用したい場合があり、次の例は動作しますが、が必要です（私はと思われるもの：この作業、シングルスレッドの例を考えると

）は不要なベクタークローンです。

use std::collections::LinkedList; 

fn calculate_vec(v: &Vec<i32>) -> i32 { 
    let mut result: i32 = 0; 
    for i 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(); 
    for v in list { 
     let v_clone = v.clone(); // <-- how to avoid this clone? 
     join_handles.push_back(thread::spawn(move || calculate_vec(&v_clone))); 
    } 
    for j in join_handles { 
     result.push_back(j.join().unwrap()); 
    } 
    return result; 
} 

fn main() { 
    let mut list: LinkedList<Vec<i32>> = LinkedList::new(); 
    // some 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 the result!"); 
    for i in result { 
     println!("{}", i); 
    } 
} 

この例では動作しますが、ベクトルは不変であるので、それは、ベクターが複製されている場合にのみ、 は、しかし、論理的に、私は、これが必要する必要があるとは思いません。

calculate_vecを呼び出すたびに新しいベクターを割り当てる必要はありません。

この単純な例は、クロージャに渡される前にデータを複製する必要なしに、どのようにマルチスレッド化できますか？

---

更新、それは所有権を取得する必要がないにもかかわらず、@のKERの提案に基づいてArcを使用していますHERESにworking example。

---

注1）私はスレッドを処理するために、サードパーティのライブラリがある知っていますが、これは錆の標準ライブラリを使用して可能であるかどうかを知るために興味があります。

注2）スレッディングに関する同様の質問がありますが、例ではスレッドにデータを書き込むことがよくありますが、ここではそうではありません。

Answer 1

問題を解決する方法は複数あります。

1. ベクターをArc<LinkedList<Vec<i32>>>に移動してクローンします。計算後、try_unwrapを使用してLinkedList<Vec<i32>>を返すことができます。これはRust標準ライブラリだけで動作します。
   
   を使用するHeres a working exampleですが、LinkedListは、インデックス作成を可能にするためにVecに置き換えられました。
   この場合、関数はこの関数に渡される引数を所有する必要があることにも注意してください。

2. crossbeamクレートを使用してスコープを参照できるスレッドを作成し、手ですべてjoin_handlesコードを実行する必要がなくなります。これは、あなたが望むのとまったく同じように動作するため、コードに与える影響は最小限に抑えられます。

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

3. scoped_threadpoolクレートを使用してください。 crossbeamのように動作しますが、タスクごとに1つのスレッドを作成するのではなく、限られた数のスレッドでタスクを分散します。（感謝@delnan）

4. は、直接データの並列処理のためのrayonクレートを使用

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