multithreading - 我如何总结使用 Rust 从 1 到 1000000 的并发性？

Question

我是 Rust 新手，我想使用并发对大量数字求和。我找到这段代码:

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);
}

线程数为10时有效，线程数大于20时无效。

我认为在任何数量的线程中都应该没问题。

我是不是误会了什么？是否有另一种方法可以并发地从 1 到 1000000 求和？

Answer 1

提供的代码有几个问题。

1. thread::spawn 创建操作系统级别的线程，这意味着现有代码不可能如标题所示扩展到多达一百万个线程。这将需要一百万个并行线程，而典型的现代操作系统最多支持几千个线程。更受限的环境，例如嵌入式系统或虚拟/半虚拟机，允许的要少得多；例如，Rust playground似乎最多允许 24 个并发线程。相反，需要创建固定的少量线程，并在它们之间仔分割配工作。
2. 在每个线程中执行的函数在锁内运行，这有效地序列化了线程完成的工作。即使可以产生任意多个线程，所写的循环执行速度也不会比单个线程实现的速度快——实际上它会慢几个数量级，因为它会花费大量时间来锁定/解锁竞争激烈的互斥体。

在 comment by Boiethios 中提供了解决此类问题同时仍然手动管理线程的好方法。 : 如果您有 4 个线程，只需在每个线程中求和 1..250k、250k..500k 等，然后求和线程函数的返回。

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

我建议使用更高级别的库来封装工作线程的创建/池化以及它们之间的工作分工。 Rayon是一个优秀的，提供了一个“并行迭代”设施，它像迭代一样工作，但自动将工作分配给多个核心。使用 Rayon，整数的并行求和如下所示:

extern crate rayon;

use rayon::prelude::*;

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