Rust中TextDocument修改所属Framework的双向可变引用实现方法

核心思路 #

由于你需要后续并行解析文档，方案需兼顾线程安全和循环引用下的可变访问：

• 用Arc（线程安全的引用计数）替代Rc，支持跨线程共享所有权
• 用Mutex（或RwLock）为Framework内部字段提供线程安全的内部可变性，解决共享引用无法修改的问题
• 循环引用通过Weak<Arc<Mutex<Framework>>>实现，避免内存泄漏，同时用线程安全容器持有Weak引用

修改后的可运行代码 #

use std::collections::HashMap;
use std::sync::{Arc, Mutex, Weak};
use std::any::type_name;

#[allow(dead_code)]
pub fn str_type_of<T>(_: &T) -> &str {
    type_name::<T>()
}

fn main() {
    // 创建Framework并包裹在Arc<Mutex>中，实现线程安全的共享与可变
    let framework = Arc::new(Mutex::new(Framework::new()));
    // 先获取可变引用填充文档map
    framework.lock().unwrap().populate_map();
    println!("framework.map {:?}", framework.lock().unwrap().map);

    // 生成Framework的Weak引用，用于绑定给TextDocument
    let framework_weak = Arc::downgrade(&framework);
    for (key, td) in framework.lock().unwrap().map.iter_mut() {
        *td.framework.lock().unwrap() = framework_weak.clone();
        println!("key {} td {:?}", key, td);

        // 通过Weak引用升级并修改Framework内容
        if let Some(framework_rc) = td.framework.lock().unwrap().upgrade() {
            let mut framework_mut = framework_rc.lock().unwrap();
            framework_mut.name = format!("updated for {}", key);
            println!("修改后的framework.name: {}", framework_mut.name);
        }
    }

    // 直接修改Framework的内容
    let mut framework_mut = framework.lock().unwrap();
    framework_mut.name = "最终修改的名称".to_string();
    println!("最终framework.name: {}", framework_mut.name);
}

#[derive(Debug)]
struct TextDocument {
    // 并行场景下用Mutex持有Weak引用，保证线程安全；单线程可替换为RefCell
    framework: Mutex<Weak<Arc<Mutex<Framework>>>>,
    i: usize,
}

#[derive(Debug)]
struct Framework {
    map: HashMap<String, TextDocument>,
    name: String,
    // 可添加进度跟踪、取消标志等字段
    progress: HashMap<String, u8>,
}

impl Framework {
    fn new() -> Framework {
        Framework {
            map: HashMap::new(),
            name: "my framework".to_string(),
            progress: HashMap::new(),
        }
    }

    fn populate_map(&mut self) {
        for i in 0..5 {
            let td = TextDocument {
                framework: Mutex::new(Weak::new()),
                i,
            };
            self.map.insert(format!("document {i}"), td);
        }
    }

    // 示例：Framework的&mut self方法，可被TextDocument调用
    fn update_progress(&mut self, doc_key: &str, progress: u8) {
        self.progress.insert(doc_key.to_string(), progress);
        println!("文档{}进度更新为{}%", doc_key, progress);
    }
}

// 为TextDocument添加修改Framework的方法
impl TextDocument {
    fn report_progress(&self, doc_key: &str, progress: u8) {
        if let Some(framework_rc) = self.framework.lock().unwrap().upgrade() {
            let mut framework_mut = framework_rc.lock().unwrap();
            framework_mut.update_progress(doc_key, progress);
        }
    }
}

关键要点说明 #

1. Arc<Mutex>：

   • Arc让Framework可以被多线程共享，每个线程持有一份引用计数
   • Mutex保证同一时间只有一个线程能获取Framework的可变引用，避免数据竞争

2. Mutex<Weak<Arc<Mutex>>>：

   • Weak引用避免了循环引用导致的内存泄漏（当所有强引用释放后，Weak引用会自动失效）
   • 并行场景下用Mutex持有Weak引用，保证对Weak引用的修改是线程安全的；单线程场景可替换为RefCell

3. 修改Framework的流程：
   通过Weak::upgrade()获取Arc<Mutex<Framework>>，再调用lock()获取MutexGuard，即可获得Framework的可变引用，进而修改字段或调用&mut self方法

4. 性能优化可选：
   如果多数场景是只读访问，少数场景是写入，可以用RwLock替代Mutex，允许多个线程同时读取，提升并发性能

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