How can I sum up using concurrency from 1 to 10000

Question

I am a newbie to Rust, and I want to sum up a large amount of numbers using concurrency. I found this code:

use std::thread;
use std::sync::{Arc, Mutex};

static NTHREAD: usize = 10;

fn main() {
    let mut threads = Vec::new();

    let x = 0;

    // A thread-safe, sharable mutex object
    let data = Arc::new(Mutex::new(x));

    for i in 1..(NTHREAD+1) {
        // Increment the count of the mutex
        let mutex = data.clone();

        threads.push(thread::spawn(move || {
            // Lock the mutex
            let n = mutex.lock();

            match n {
                Ok(mut n) => *n += i,
                Err(str) => println!("{}", str)
            }
        }));
    }

    // Wait all threads ending
    for thread in threads {
        let _ = thread.join().unwrap();
    }

    assert_eq!(*data.lock().unwrap(), 55);
}

This works when the threads are 10, but does not work when the threads are larger than 20.

I think it should be fine in any number of threads.

Do I misunderstand something? Is there another way to sum up from 1 to 1000000 with concurrency?

Answer 1

There are several problems with the provided code.

1. thread::spawn creates an OS-level thread, which means the existing code cannot possibly scale to numbers up to a million as indicated in the title. That would require a million threads in parallel, where typical modern OS'es support up to a few thousands of threads at best. More constrained environments, such as embedded systems or virtual/paravirtual machines, allow much less than that; for example, the Rust playground appears to allow a maximum of 24 concurrent threads. Instead, one needs to create a fixed small number of threads, and carefully divide the work among them.
2. The function executing in each thread runs inside a lock, which effectively serializes the work done by the threads. Even if one could spawn arbitrarily many threads, the loop as written would execute no faster than what would be achieved by a single thread - and in practice it would be orders of magnitude slower because it would spend a lot of time on locking/unlocking of a heavily contended mutex.

One good way to approach this kind of problem while still managing threads manually is provided in the comment by Boiethios: if you have 4 threads, just sum 1..250k, 250k..500k, etc. in each thread and then sum up the return of the threaded functions.

Or is there another way to sum up from 1 to 1000000 with concurrency?

I would recommend using a higher-level library that encapsulates creation/pooling of worker threads and division of work among them. Rayon is an excellent one, providing a "parallel iteration" facility, which works like iteration, but automatically dividing up the work among multiple cores. Using Rayon, parallel summing of integers would look like this:

extern crate rayon;

use rayon::prelude::*;

fn main() {
    let sum: usize = (1..1000001).collect::<Vec<_>>().par_iter().sum();
    assert_eq!(sum, 500000500000);
}