遍历Arc<Mutex<Vec>>时如何生成并发线程并高效处理其中元素？

你遇到的性能问题几乎都是Mutex锁粒度过大导致的：如果遍历Arc<Mutex<Vec>>时全程持有锁，所有线程只能串行等待锁释放，本质还是串行执行，甚至比单线程多了锁竞争的额外开销，自然没有速度优势。

1. 优先使用细粒度锁，替换全局大锁 #

不要给整个Vec套Mutex，改为给Vec内的每个单独条目套Mutex，也就是把Arc<Mutex<Vec<T>>>替换为Arc<Vec<Mutex<T>>>。这种场景下不同线程访问不同条目时不会产生锁竞争，完全可以并行执行。
示例代码如下：

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

fn main() {
    // 细粒度锁结构：每个元素独立加锁
    let shared_data = Arc::new(
        (0..1000).map(|val| Mutex::new(val)).collect::<Vec<_>>()
    );
    let mut thread_handles = Vec::with_capacity(shared_data.len());

    // 遍历索引不需要持有锁，不会产生竞争
    for idx in 0..shared_data.len() {
        let data_clone = Arc::clone(&shared_data);
        // 不在锁持有区间启动线程，避免拉长锁持有时间
        let handle = thread::spawn(move || {
            // 仅在需要操作单个元素时加锁，持有锁的时间极短
            let mut item = data_clone[idx].lock().unwrap();
            *item *= 2; // 你的业务处理逻辑
        });
        thread_handles.push(handle);
    }

    // 等待所有线程执行完成
    for handle in thread_handles {
        handle.join().unwrap();
    }
}

2. 必须使用全局大锁时，先拷贝任务再并行处理 #

如果业务逻辑不允许拆分细粒度锁，就一次性持有锁把所有需要处理的任务拷贝到本地，立刻释放锁之后再分发给多线程处理，不要在锁持有区间执行任何和读任务无关的操作。
示例代码如下：

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

fn process_task(task: i32) -> i32 {
    // 你的业务处理逻辑，这里模拟耗时计算
    task * task
}

fn main() {
    let shared_data = Arc::new(Mutex::new((0..1000).collect::<Vec<i32>>()));
    // 仅加锁一次，拷贝完任务立刻释放锁，锁持有时间极短
    let local_tasks = shared_data.lock().unwrap().clone();
    let mut thread_handles = Vec::with_capacity(local_tasks.len());

    for task in local_tasks {
        let handle = thread::spawn(move || process_task(task));
        thread_handles.push(handle);
    }

    // 收集处理结果
    let process_results: Vec<i32> = thread_handles.into_iter()
        .map(|h| h.join().unwrap())
        .collect();
}

• 如果你处理的是CPU密集型任务，线程数不要超过当前设备的CPU核心数，否则频繁的上下文切换会额外消耗性能
• 如果单个任务的执行耗时非常短，线程启停和调度的开销会超过并行收益，这种场景建议用线程池批量处理任务，或者直接用单线程
• 所有非必要的操作都不要放在锁持有区间执行，尽可能缩短锁的持有时间

内容的提问来源于stack exchange，提问作者my_stack