Rust多线程优化：仅锁定向量特定索引的实现方案

你的核心问题在于过早持有全局数组锁，耗时计算阶段完全不需要占用锁资源，只需要在最终修改指定索引时，锁定对应的单个元素即可。以下是两种基于标准库的实现方案：

方案一：元素级Mutex（安全，无需unsafe） #

直接将数组的每个元素包装为Mutex<f32>，这样线程仅在修改目标元素时持有该元素的锁，其余时间（包括耗时计算）不占用任何锁资源，完全支持并行执行。

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

use rand::Rng;

fn main() {
    // 初始化每个元素带Mutex的数组
    let container = Arc::new([
        Mutex::new(0.0), Mutex::new(0.0), Mutex::new(0.0),
        Mutex::new(0.0), Mutex::new(0.0), Mutex::new(0.0),
        Mutex::new(0.0), Mutex::new(0.0), Mutex::new(0.0),
        Mutex::new(0.0)
    ]);

    let mut threads = vec![];

    for _ in 0..10 {
        let clone = Arc::clone(&container);

        threads.push(thread::spawn(move || {
            // 先执行耗时计算（这里模拟生成随机索引）
            let mut rng = rand::thread_rng();
            let index = rng.gen_range(0..10);
            thread::sleep(Duration::from_millis(1000));

            // 仅锁定目标索引对应的元素，修改后立即释放
            let mut elem = clone[index].lock().unwrap();
            println!("Changing index {}", index);
            *elem += 1.0;
        }));
    }

    for thread in threads {
        thread.join().unwrap();
    }

    // 打印结果
    let result: Vec<f32> = container.iter().map(|m| *m.lock().unwrap()).collect();
    println!("{:?}", result);
}

方案二：unsafe结合元素级锁（适合需要直接操作原始数组的场景） #

如果需要保持原始f32数组的结构，可利用数组生命周期长于所有线程的特性，通过unsafe获取原始指针，配合元素级的空Mutex（仅用于互斥同步）实现细粒度锁：

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

use rand::Rng;

fn main() {
    // 原始f32数组，用Arc保证生命周期
    let data = Arc::new([0.0; 10]);
    // 元素级锁数组，用于同步每个索引的修改
    let locks = Arc::new([
        Mutex::new(()), Mutex::new(()), Mutex::new(()),
        Mutex::new(()), Mutex::new(()), Mutex::new(()),
        Mutex::new(()), Mutex::new(()), Mutex::new(()),
        Mutex::new(())
    ]);

    let mut threads = vec![];

    for _ in 0..10 {
        let data_clone = Arc::clone(&data);
        let locks_clone = Arc::clone(&locks);

        threads.push(thread::spawn(move || {
            // 先执行耗时计算
            let mut rng = rand::thread_rng();
            let index = rng.gen_range(0..10);
            thread::sleep(Duration::from_millis(1000));

            // 锁定目标索引的同步锁
            let _guard = locks_clone[index].lock().unwrap();
            // unsafe修改原始数组（已知数组生命周期长于所有线程，无悬垂指针风险）
            let ptr = Arc::as_ptr(&data_clone) as *mut f32;
            unsafe {
                println!("Changing index {}", index);
                *ptr.add(index) += 1.0;
            }
        }));
    }

    for thread in threads {
        thread.join().unwrap();
    }

    // 打印结果
    println!("{:?}", data);
}

关键优化点 #

1. 锁粒度最小化：从全局数组锁改为单个元素锁，避免计算阶段阻塞其他线程
2. 锁持有时间最短：仅在修改元素的瞬间持有锁，耗时计算阶段完全并行
3. 完全基于标准库：无需依赖第三方crate，两种方案均符合要求

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