如何为Rust结构体字段创建间接线程屏障？并发问题求解

方案一：转移元素到线程安全结构（无unsafe） #

这个方案通过将原Vec<usize>的元素转移到Arc<Mutex<usize>>的集合中，实现线程安全的并行访问，同时不修改原结构体定义。

实现步骤 #

1. 重构function函数：修改函数签名，使其接受线程安全的数据集合，而非原结构体的可变引用。
2. 构建线程安全数据：将原结构体的data1元素转移（或克隆）到Arc<Mutex<usize>>的Vec中。
3. 并行执行：使用并行迭代器（如rayon库）对每个索引调用重构后的function。
4. 可选：写回原结构体：如果需要保留修改结果，可将元素从线程安全结构移回原data1（用户不关注结果可省略）。

示例代码：

use std::sync::{Arc, Mutex};
use rayon::prelude::*; // 需要在Cargo.toml添加rayon依赖

struct MyStruct {
    data1: Vec<usize>,
}

// 修改后的function
fn function(data: &[Arc<Mutex<usize>>], i: usize) {
    // 锁定要修改的元素i
    let mut guard_i = data[i].lock().unwrap();
    let current_val = *guard_i;
    // 计算依赖的索引j
    let j = (i - current_val) % data.len();
    // 锁定要读取的元素j
    let guard_j = data[j].lock().unwrap();
    // 执行修改操作
    *guard_i += *guard_j;
}

fn main() {
    // 初始化原结构体
    let mut my_struct = MyStruct { data1: vec![1, 2, 3, 4, 5] };

    // 将原data1的元素转移到线程安全集合（若要保留原数据，改用clone()）
    let thread_safe_data: Vec<Arc<Mutex<usize>>> = my_struct.data1
        .drain(..)
        .map(|val| Arc::new(Mutex::new(val)))
        .collect();

    // 并行处理每个元素
    (0..thread_safe_data.len())
        .into_par_iter()
        .for_each(|i| function(&thread_safe_data, i));

    // 可选：将修改后的元素写回原结构体
    my_struct.data1 = thread_safe_data
        .into_iter()
        .map(|arc| Arc::try_unwrap(arc).unwrap().into_inner().unwrap())
        .collect();
}

方案二：使用unsafe指针（无元素转移） #

如果必须直接操作原结构体的data1元素，不进行转移，可以通过unsafe获取元素的可变指针，配合Mutex实现线程安全访问。此方案要求原data1的长度在并行操作期间保持不变（用户已说明结构体已完成初始化，满足条件）。

实现步骤 #

1. 创建指针锁集合：遍历原data1，为每个元素创建包含可变指针的Mutex。
2. 标记结构为Send/Sync：手动实现Send和Sync trait，确保指针集合可跨线程传递。
3. 重构function函数：通过锁定指针，使用unsafe操作原元素的值。
4. 并行执行：使用并行迭代器处理每个索引。

示例代码：

use std::sync::Mutex;
use rayon::prelude::*;

struct MyStruct {
    data1: Vec<usize>,
}

// 包装指针锁的结构，手动实现Send和Sync
struct ElementLocks(Vec<Mutex<*mut usize>>);

unsafe impl Send for ElementLocks {}
unsafe impl Sync for ElementLocks {}

// 修改后的function
fn function(locks: &ElementLocks, i: usize) {
    // 锁定元素i的指针
    let mut guard_i = locks.0[i].lock().unwrap();
    let elem_i = unsafe { &mut **guard_i };
    let current_val = *elem_i;
    // 计算依赖的索引j
    let j = (i - current_val) % locks.0.len();
    // 锁定元素j的指针
    let guard_j = locks.0[j].lock().unwrap();
    let elem_j = unsafe { &**guard_j };
    // 执行修改操作
    *elem_i += *elem_j;
}

fn main() {
    let mut my_struct = MyStruct { data1: vec![1, 2, 3, 4, 5] };

    // 创建每个元素的指针锁集合
    let locks = ElementLocks(
        my_struct.data1
            .iter_mut()
            .map(|elem| Mutex::new(elem as *mut usize))
            .collect()
    );

    // 并行处理每个元素
    (0..locks.0.len())
        .into_par_iter()
        .for_each(|i| function(&locks, i));
}

原方案问题分析 #

你之前的ThreadedDataLocks结构持有Vec<Mutex<&'a mut T>>，核心问题是&'a mut T是独占借用——一旦创建这个结构，原MyStruct的data1会被完全独占，无法再被其他代码访问。解决方案的核心是放弃独占引用，改用共享所有权（Arc）或unsafe指针实现线程安全的并行访问，同时避免绑定原结构体的生命周期。

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