Rust中的引用循环与内存泄漏详解

enum List {
    Cons(i32, RefCell<Rc<List>>),
    Nil,
}

impl List {
    fn tail(&self) -> Option<&RefCell<Rc<List>>> {
        match self {
            List::Cons(_, tail) => Some(tail),
            List::Nil => None,
        }
    }
}

fn main() {
    let a = Rc::new(Cons(5, RefCell::new(Rc::new(Nil))));
    println!("a 的引用计数 = {}", Rc::strong_count(&a));

    let b = Rc::new(Cons(10, RefCell::new(Rc::clone(&a))));
    println!("a 的引用计数 = {}", Rc::strong_count(&a));
    println!("b 的引用计数 = {}", Rc::strong_count(&b));

    if let Some(link) = a.tail() {
        *link.borrow_mut() = Rc::clone(&b);
    }

    // 此时，a 和 b 互相引用，形成循环
    println!("a 的引用计数 = {}", Rc::strong_count(&a));
    println!("b 的引用计数 = {}", Rc::strong_count(&b));

    // 如果在此处尝试打印整个列表，会因为无限循环而导致栈溢出
    // println!("a = {:?}", a);
}

use std::rc::{Rc, Weak};
use std::cell::RefCell;

#[derive(Debug)]
struct Node {
    value: i32,
    parent: RefCell<Weak<Node>>,
    children: RefCell<Vec<Rc<Node>>>,
}

impl Node {
    fn new(value: i32) -> Rc<Node> {
        Rc::new(Node {
            value,
            parent: RefCell::new(Weak::new()),
            children: RefCell::new(vec![]),
        })
    }
}

fn main() {
    // 创建一个没有父节点的叶子节点
    let leaf = Node::new(3);
    println!("leaf 的 parent = {:?}", leaf.parent.borrow().upgrade());

    {
        // 在内部作用域中创建一个分支节点，将叶子节点作为其子节点
        let branch = Node::new(5);
        *leaf.parent.borrow_mut() = Rc::downgrade(&branch);
        branch.children.borrow_mut().push(Rc::clone(&leaf));

        println!("branch 的引用计数 = {}, 弱引用计数 = {}",
            Rc::strong_count(&branch),
            Rc::weak_count(&branch)
        );
        println!("leaf 的引用计数 = {}, 弱引用计数 = {}",
            Rc::strong_count(&leaf),
            Rc::weak_count(&leaf)
        );
    }

    // 此时，branch 已经离开作用域被释放，leaf 的 parent 升级后为 None
    println!("leaf 的 parent = {:?}", leaf.parent.borrow().upgrade());
    println!("leaf 的引用计数 = {}", Rc::strong_count(&leaf));
}