Kod nie działa równolegle podczas używania wątku :: scoped

Question

Czy ktoś mógłby wyjaśnić, dlaczego poniższy kod nie działa równolegle? Chyba nie rozumiem, jak thread::scoped prace ..

use std::thread; 
use std::sync::{Arc, Mutex}; 
use std::time::Duration; 
use std::old_io::timer; 

fn main() { 
    let buf = Arc::new(Mutex::new(Vec::<String>::new())); 
    let res = test(buf); 
    println!("{:?}", *res.lock().unwrap()); 
} 

fn test(buf: Arc<Mutex<Vec<String>>>) -> Arc<Mutex<Vec<String>>> { 
    let guards: Vec<_> = (0..3).map(|i| { 
     let mtx = buf.clone(); 
     thread::scoped(|| { 
      println!("Thread: {}", i); 
      let mut res = mtx.lock().unwrap(); 
      timer::sleep(Duration::seconds(5)); 
      res.push(format!("thread {}", i)); 
     }); 
    }).collect(); 
    buf 
} 

Kod jest oparty na przykładach here gdzie stwierdził:

scoped funkcja przyjmuje jeden argument, zamknięcie, wskazaną przez podwójne paski ||. To zamknięcie jest wykonywane w nowym wątku utworzonym przez zakres. Ta metoda nazywa się scoped, ponieważ zwraca 'join guard', która automatycznie dołącza do wątku podrzędnego, gdy wykracza poza zakres. Ponieważ zbieramy tych strażników do Vec, a ten wektor wykracza poza zakres naszego programu, nasz program będzie czekał na zakończenie każdego wątku.

Dzięki

Answer 1

Jest to trudne przypadek. Problemem jest skromny średnik. Spójrz na ten kod zminimalizowanym:

thread::scoped(|| {}); 

To oznacza, że ​​średnik wynik collectnie jest wektorem JoinGuard s - to Vec<()>! Każdy JoinGuard jest natychmiast upuszczany, zmuszając koniec nici do rozpoczęcia kolejnej iteracji.

Po rozwiązaniu tego problemu, pojawi się następny problem, który oznacza, że ​​i i mtx nie żyją wystarczająco długo. Musisz move je do zamknięcia:

thread::scoped(move || {})