`Rc<RefCell<T>>` y `Arc<Mutex<T>>`: estado compartido y mutable

Dos herramientas, cada una con media solución. Rc<T> te da propiedad compartida —varios dueños del mismo dato, contados por referencia—, pero solo te presta acceso &: no puedes mutar a través de él. RefCell<T> te da mutación tras un & compartido, pero es de un solo dueño: no lo puedes duplicar. Ninguno, por separado, te deja lo que a menudo necesitas de verdad: varios dueños que además puedan modificar el dato común. La solución no es un tipo nuevo, sino la composición de los dos: Rc<RefCell<T>>. El Rc reparte la propiedad; el RefCell, encajado dentro, concede la mutación. Es el patrón con el que se construyen grafos, árboles con enlaces al padre y todo estado compartido y mutable de un solo hilo.

Apilar las dos mitades

La composición se lee de fuera adentro: Rc es la capa externa —la que se clona para repartir dueños—, y RefCell la interna —la que cada dueño usa para mutar—. Clonar el Rc no copia el dato: copia el puntero y sube el recuento, de modo que todos comparten el mismo RefCell.

use std::cell::RefCell;
use std::rc::Rc;

let compartido = Rc::new(RefCell::new(vec![1, 2, 3]));

let otro = Rc::clone(&compartido);      // segundo dueno del MISMO RefCell
otro.borrow_mut().push(4);              // muta a traves de una de las manos

assert_eq!(*compartido.borrow(), vec![1, 2, 3, 4]);   // la otra mano lo ve
assert_eq!(Rc::strong_count(&compartido), 2);

Ambos bindings apuntan al mismo RefCell; el push hecho por otro lo observa compartido. Cada capa hace su trabajo: Rc garantiza que el dato vive mientras quede un dueño; RefCell garantiza, en ejecución, que las mutaciones no se solapan.

El árbol con enlace al padre

El caso donde este patrón se vuelve imprescindible es una estructura con referencias en dos sentidos: un árbol cuyos nodos conocen a sus hijos y a su padre. Los hijos se poseen con Rc (el padre los mantiene vivos); el padre se referencia con Weak (un puntero que no cuenta para la propiedad):

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

struct Nodo {
    valor: i32,
    padre: RefCell<Weak<Nodo>>,        // hacia arriba: no posee
    hijos: RefCell<Vec<Rc<Nodo>>>,     // hacia abajo: posee
}

fn main() {
    let raiz = Rc::new(Nodo {
        valor: 1,
        padre: RefCell::new(Weak::new()),
        hijos: RefCell::new(vec![]),
    });

    let hoja = Rc::new(Nodo {
        valor: 2,
        padre: RefCell::new(Weak::new()),
        hijos: RefCell::new(vec![]),
    });

    *hoja.padre.borrow_mut() = Rc::downgrade(&raiz);   // enlace debil al padre
    raiz.hijos.borrow_mut().push(Rc::clone(&hoja));    // enlace fuerte al hijo

    let padre = hoja.padre.borrow().upgrade();          // Weak -> Option<Rc>
    assert_eq!(padre.unwrap().valor, 1);
}

Rc::downgrade produce un Weak, que para leerse debe upgrade a un Option<Rc> —Some si el destino sigue vivo, None si ya murió—. El RefCell alrededor de cada campo es lo que permite reconfigurar el árbol —añadir hijos, cambiar el padre— a través de los & compartidos que reparte el Rc.

El salto a varios hilos: Arc<Mutex<T>>

Rc<RefCell<T>> es, a propósito, de un solo hilo: ambos son !Send y !Sync, y el compilador te impedirá enviarlos a otro hilo. Es una protección, no una carencia: sus contadores y banderas no son atómicos. Para el mismo patrón entre hilos, se cambia cada capa por su versión sincronizada:

use std::sync::{Arc, Mutex};
use std::thread;

let contador = Arc::new(Mutex::new(0));
let mut manos = vec![];

for _ in 0..4 {
    let c = Arc::clone(&contador);
    manos.push(thread::spawn(move || {
        let mut n = c.lock().unwrap();   // adquiere el cerrojo; se suelta al salir
        *n += 1;
    }));
}
for h in manos { h.join().unwrap(); }
assert_eq!(*contador.lock().unwrap(), 4);

flowchart TB
subgraph Un hilo
  rc[Rc aporta varios duenos] --> combo[Rc de RefCell de T]
  refcell[RefCell aporta mutacion tras un ampersand] --> combo
  combo --> uso[N duenos que pueden mutar]
end
subgraph Varios hilos
  arc[Arc recuento atomico] --> combo2[Arc de Mutex de T]
  mutex[Mutex cerrojo con exclusion] --> combo2
  combo2 --> uso2[Estado compartido entre hilos]
end
style combo fill:#89b4fa,color:#11111b
style combo2 fill:#cba6f7,color:#11111b
style uso fill:#a6e3a1,color:#11111b
style uso2 fill:#a6e3a1,color:#11111b