Changes

for handle in handles { handle.join().unwrap(); }

println!("Final Result: {}", *mutex.lock().unwrap());

for handle in handles { handle.join().unwrap(); }

println!("Final Result: {}", *mutex.lock().unwrap());

Parallel iterators are implemented with a more primitive method called join which takes 2 closures and runs them in parallel. The code snippet below demonstrates quick sort increment algorithm:

 fn quick_sort<T:PartialOrd+Send>increment_all(vslice: &mut [Ti32]) { if vslice.len() <1000 { for p in slice { *p += 1 ; } } else { returnlet mid_point = slice.len() / 2; let (left, right) = slice.split_at_mut(mid_point); rayon::join(|| increment_all(left), || increment_all(right));

Rayon borrowed work stealing concepts from Cilk project. The library attempts to dynamically ascertain how much multi-threading resources are available. The idea is very simple: there is always a pool of worker threads available, waiting for some work to do. When you call join the first time, we shift over into that pool of threads.  [[File:Rust_Join1.png]] But if you call join(a, b) from a worker thread W, then W will place b into its work queue, advertising that this is work that other worker threads might help out with. W will then start executing a. While W is busy with a, other threads might come along and take b from its queue. That is called stealing b. Once a is done, W checks whether b was stolen by another thread and, if not, executes b itself. If W runs out of jobs in its own queue, it will look through the other threads' queues and try to steal work from them [[File:Rust_Join_2.png|600px]]