Rust进阶(9)-弱引用

弱引用

概述

弱引用Weak 属于Rc包
特点：

1. 弱引用通过Rc::downgrade传递Rc实例的引用，调用Rc::downgrade会得到Weak类型的智能指针，同时将weak_count加1（不是将strong_count加1）
2. 区别在于weak_count无需计数为0就能使Rc实例被清理，只要strong_count为0就可以了
3. 可以通过Rc::upgrade方法返回Option<Rc>对象
4. 通俗的讲，弱引用就是：会作为截止标记，不会进一步循环嵌套

1. 案例-循环引用

问题代码：
tail打印，因为无限循环嵌套Cons，导致无法打印出完整的tail.

#[derive(Debug)]
enum List {
   Cons(i32, RefCell<Rc<List>>),
   Nil,
}

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

use crate::List::{Cons, Nil};
use std::rc::Rc;
use std::cell::RefCell;


fn main() {
   let a = Rc::new(Cons(5,RefCell::new(Rc::new(Nil))));
   println!("1, a rc count = {}",Rc::strong_count(&a));
   println!("1, a tail = {:?}",a.tail());

   //通过clone，将b尾部指向a
   let b = Rc::new(Cons(10,RefCell::new(Rc::clone(&a))));
   println!("2, a rc count = {}",Rc::strong_count(&a));
   println!("2, b rc count = {}",Rc::strong_count(&b));
   println!("2, b tail = {:?}",b.tail());

   if let Some(link) = a.tail(){
      *link.borrow_mut() = Rc::clone(&b);
   }
   println!("3, a rc count = {}",Rc::strong_count(&a));
   println!("3, b rc count = {}",Rc::strong_count(&b));
   //下面打印的问题：会无限死循环打印相互嵌套的Const
   // println!("3, a tail = {:?}",a.tail());
}

1, a rc count = 1
1, a tail = Some(RefCell { value: Nil })
2, a rc count = 2
2, b rc count = 1
2, b tail = Some(RefCell { value: Cons(5, RefCell { value: Nil }) })
3, a rc count = 2
3, b rc count = 2
# a.tail输出死循环

解决方式：
弱引用Weak

//使用弱引用解决上述问题：
#[derive(Debug)]
enum List {
   Cons(i32, RefCell<Weak<List>>),
   Nil,
}

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

use crate::List::{Cons, Nil};
use std::rc::Rc;
use std::rc::Weak;
use std::cell::RefCell;

fn main() {
   let a = Rc::new(Cons(5,RefCell::new(Weak::new())));
   println!("1, a strong count = {},weak count= {}",Rc::strong_count(&a),Rc::weak_count(&a));
   println!("1, a tail = {:?}",a.tail());

   let b = Rc::new(Cons(10,RefCell::new(Weak::new())));
   //b的尾部指向a
   if let Some(link) = b.tail(){
      *link.borrow_mut() = Rc::downgrade(&a);
   }
   println!("2, a strong count = {},weak count= {}",Rc::strong_count(&a),Rc::weak_count(&a));
   println!("2, b strong count = {},weak count= {}",Rc::strong_count(&b),Rc::weak_count(&b));
   println!("2, b tail = {:?}",b.tail());
   //a的尾部指向b
   if let Some(link) = b.tail(){
      *link.borrow_mut() = Rc::downgrade(&b);
   }

   println!("3, a strong count = {},weak count= {}",Rc::strong_count(&a),Rc::weak_count(&a));
   println!("3, b strong count = {},weak count= {}",Rc::strong_count(&b),Rc::weak_count(&b));
   println!("3, b tail = {:?}",b.tail());
}

输出结果：

1, a strong count = 1,weak count= 0
1, a tail = Some(RefCell { value: (Weak) })
2, a strong count = 1,weak count= 1
2, b strong count = 1,weak count= 0
2, b tail = Some(RefCell { value: (Weak) })
3, a strong count = 1,weak count= 0
3, b strong count = 1,weak count= 1
3, b tail = Some(RefCell { value: (Weak) })

2. 案例-树形结构

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

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

fn main() {
    //叶子节点
    let leaf = Rc::new(Node {
        value: 3,
        parent: RefCell::new(Weak::new()),
        children: RefCell::new(vec![]),
    });
    //println!("leaf parent = {:?}", leaf.parent.borrow().upgrade());
    println!(
        "1. leaf strong = {}, weak = {}",
        Rc::strong_count(&leaf),
        Rc::weak_count(&leaf),
    );
    //分支节点
    let branch = Rc::new(Node {
        value: 5,
        parent: RefCell::new(Weak::new()),
        children: RefCell::new(vec![Rc::clone(&leaf)]),
    });
    println!(
        "2. branch strong = {}, weak = {}",
        Rc::strong_count(&branch),
        Rc::weak_count(&branch),
    );

    *leaf.parent.borrow_mut() = Rc::downgrade(&branch);
    println!("leaf parent = {:?}", leaf.parent.borrow().upgrade());
    println!(
        "2. branch strong = {}, weak = {}",
        Rc::strong_count(&branch),
        Rc::weak_count(&branch),
    );
    println!(
        "1. leaf strong = {}, weak = {}",
        Rc::strong_count(&leaf),
        Rc::weak_count(&leaf),
    );
}

输出结果：

1. leaf strong = 1, weak = 0
2. branch strong = 1, weak = 0
2. branch strong = 1, weak = 1
1. leaf strong = 2, weak = 0

总结

本文编辑完毕

参考

[1] Rust 程序设计语言