Rust共享内存性能：快速递增索引

针对你提出的「多线程对Vec的不重叠切片执行递增操作」场景，以下是几种能达到最快速度的构造，按性能从高到低排序：

1. Arc<UnsafeCell<Vec<T>>> + 原始指针（手动无锁，性能天花板） #

这种方式完全规避同步开销，直接操作内存，是速度最快的方案，但需要手动保证切片绝对不重叠（否则会触发数据竞争，导致未定义行为）。

代码示例 #

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

fn main() {
    let vec_len = 10000;
    let shared_data = Arc::new(UnsafeCell::new(vec![0; vec_len]));
    // 假设传入的切片范围无重叠
    let slices = vec![(0, 2500), (2500, 5000), (5000, 7500), (7500, 10000)];

    let mut thread_handles = Vec::new();
    for (start_idx, end_idx) in slices {
        let data_clone = Arc::clone(&shared_data);
        thread_handles.push(thread::spawn(move || {
            // 安全前提：所有线程处理的切片范围完全不重叠
            let vec_ptr = (*data_clone.get()).as_mut_ptr();
            for idx in start_idx..end_idx {
                unsafe {
                    *vec_ptr.add(idx) += 1;
                }
            }
        }));
    }

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

    // 验证结果
    let final_vec = unsafe { &*shared_data.get() };
    assert!(final_vec.iter().all(|&val| val == 1));
}

优缺点 #

• 优点：零同步开销，纯内存直接操作，性能拉满
• 缺点：需要unsafe代码，必须严格保证切片无重叠，否则会出现未定义行为

2. Rayon并行迭代（安全高效，无需手动线程管理） #

如果不想写unsafe代码，Rayon库的并行迭代是最优选择。它内部基于工作窃取算法自动管理线程池，能高效分配任务，性能几乎和手动无锁方案持平，且完全安全。

代码示例 #

use rayon::prelude::*;

fn main() {
    let mut data = vec![0; 10000];
    let slices = vec![(0, 2500), (2500, 5000), (5000, 7500), (7500, 10000)];

    // 并行处理所有切片
    slices.par_iter().for_each(|&(start, end)| {
        for idx in start..end {
            data[idx] += 1;
        }
    });

    assert!(data.iter().all(|&val| val == 1));
}

优缺点 #

• 优点：代码简洁，自动负载均衡，安全无unsafe，性能接近手动无锁方案
• 缺点：需要引入第三方库（Rayon），但它是Rust生态中非常成熟的并行库

3. 原子类型（安全处理重叠场景，性能略降） #

如果切片可能存在重叠，或者无法保证无重叠，原子类型是安全的选择。原子操作会保证内存访问的原子性，但相比直接内存操作有轻微开销。

代码示例 #

use std::sync::{Arc, atomic::{AtomicI32, Ordering}};
use std::thread;

fn main() {
    let vec_len = 10000;
    let shared_data = Arc::new(vec![AtomicI32::new(0); vec_len]);
    let slices = vec![(0, 2500), (2500, 5000), (5000, 7500), (7500, 10000)];

    let mut thread_handles = Vec::new();
    for (start_idx, end_idx) in slices {
        let data_clone = Arc::clone(&shared_data);
        thread_handles.push(thread::spawn(move || {
            for idx in start_idx..end_idx {
                // 使用Relaxed内存顺序，仅保证原子性，开销最小
                data_clone[idx].fetch_add(1, Ordering::Relaxed);
            }
        }));
    }

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

    assert!(shared_data.iter().all(|val| val.load(Ordering::Relaxed) == 1));
}

优缺点 #

• 优点：完全安全，无需unsafe，支持重叠切片场景
• 缺点：原子类型会增加内存占用，操作开销略高于直接内存访问

性能总结 #

1. 手动无锁方案：性能最高，适合能严格保证切片无重叠的场景
2. Rayon并行迭代：性价比最高，安全且性能接近手动方案，适合大多数场景
3. 原子类型：安全但性能略降，适合切片可能重叠的场景

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