如何用Arc和Weak创建循环引用？构造含B实例的A遇问题

你遇到的这个问题在Rust里挺常见的——当你想创建一个被Arc包裹的结构体A，同时让它内部的B实例都持有指向A的Weak引用时，常规操作会卡在Arc的不可变性上：一旦生成了Weak引用，Arc::get_mut就没法用了，直接修改map更是不可能。下面给你几个靠谱的方案，既满足构造完成后map只读、无额外运行时检查的要求，还能解决这个循环引用的初始化问题：

方案一：用Arc::get_mut的临时替换技巧（完全安全） #

虽然创建Weak后Arc::get_mut会返回None，但我们可以先创建一个空的Arc<A>，这时候因为只有这一个强引用，Arc::get_mut能拿到可变引用。我们先基于这个空Arc生成所有B需要的Weak引用，再把map填充好，整个过程完全安全：

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

struct A {
    map: HashMap<u32, Vec<B>>,
}

struct B {
    weak: Weak<A>,
}

fn main() {
    // 先创建一个空的Arc<A>，此时没有其他强引用，get_mut可以拿到可变权限
    let mut a = Arc::new(A { map: HashMap::new() });
    
    // 生成指向这个空Arc的Weak引用，用来创建B实例
    let weak_a = Arc::downgrade(&a);
    let b1 = B { weak: weak_a.clone() };
    let b2 = B { weak: weak_a.clone() };
    let b3 = B { weak: weak_a };
    
    // 因为此时只有这一个强引用，get_mut能获取到可变引用，直接填充map
    if let Some(a_mut) = Arc::get_mut(&mut a) {
        a_mut.map.insert(5, vec![b1, b2]);
        a_mut.map.insert(10, vec![b3]);
    }
    
    // 现在a已经构造完成，后续map不会再被修改，完全可以正常使用
}

这个方法不需要任何unsafe，构造完成后map是不可变的，访问时也没有额外的运行时检查，非常适合你的需求。

方案二：UnsafeCell配合unsafe代码（灵活但需谨慎） #

如果你想要更直接的实现方式，可以用UnsafeCell包裹map，这样即使Arc已经被共享，也能在unsafe块中修改它——前提是你能严格保证构造完成后永远不再修改map，避免并发或数据竞争问题：

use std::cell::UnsafeCell;
use std::collections::HashMap;
use std::sync::{Arc, Weak};

struct A {
    map: UnsafeCell<HashMap<u32, Vec<B>>>,
}

// 手动实现Sync：因为构造完成后map只读，满足Sync的安全要求
unsafe impl Sync for A {}

struct B {
    weak: Weak<A>,
}

fn main() {
    let a = Arc::new(A {
        map: UnsafeCell::new(HashMap::new()),
    });
    
    // 先生成Weak引用，创建所有B实例
    let weak_a = Arc::downgrade(&a);
    let b1 = B { weak: weak_a.clone() };
    let b2 = B { weak: weak_a.clone() };
    let b3 = B { weak: weak_a };
    
    // 构造阶段用unsafe修改map，构造完成后绝对不能再碰这个修改逻辑
    unsafe {
        let map = &mut *a.map.get();
        map.insert(5, vec![b1, b2]);
        map.insert(10, vec![b3]);
    }
    
    // 后续访问map时，直接用unsafe获取不可变引用，无运行时检查
    let map = unsafe { &*a.map.get() };
    println!("{:?}", map.get(&5));
}

这里的关键是要遵守承诺：构造完成后map必须是只读的，否则会触发未定义行为。手动实现Sync是因为UnsafeCell本身不具备Sync特性，但我们的使用场景符合Sync的安全条件。

方案三：Nightly特性Arc::new_cyclic（官方推荐的自引用方案） #

如果你可以使用Nightly版本的Rust，Arc::new_cyclic就是专门为这种自引用场景设计的API，它允许你在创建Arc的同时拿到对应的Weak引用，完全不需要unsafe代码，写法也最简洁：

#![feature(arc_new_cyclic)]

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

struct A {
    map: HashMap<u32, Vec<B>>,
}

struct B {
    weak: Weak<A>,
}

fn main() {
    let a = Arc::new_cyclic(|weak_a| {
        // 这里的weak_a就是指向即将创建的Arc<A>的Weak引用
        let b1 = B { weak: weak_a.clone() };
        let b2 = B { weak: weak_a.clone() };
        let b3 = B { weak: weak_a.clone() };
        
        // 直接构造完整的A实例
        A {
            map: HashMap::from([
                (5, vec![b1, b2]),
                (10, vec![b3]),
            ]),
        }
    });
    
    // 构造完成，直接使用即可
    println!("{:?}", a.map.get(&5));
}

这个方法是官方推荐的自引用Arc初始化方案，唯一的限制就是需要启用Nightly特性。

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