Arc de T: compartir entre hilos con conteo atómico

Rc es rápido porque asume que nadie más toca su contador; esa suposición se rompe en cuanto aparece un segundo hilo. Arc<T> —atomically reference counted— es exactamente la misma idea de propiedad compartida por conteo, con una sola diferencia decisiva: sus contadores son atómicos, de modo que varios hilos pueden clonar y soltar el mismo dato sin que las cuentas se pisen. Esa atomicidad es lo que convierte a Arc en Send + Sync y le abre las puertas de la concurrencia; y es también su coste, porque una operación atómica es más cara que un incremento normal. Arc es el cimiento del estado compartido entre hilos, casi siempre del brazo de un Mutex.

Rc no cruza el hilo; Arc sí

El mismo código que compartía dentro de un hilo con Rc es rechazado en cuanto intentas mover la participación a otro hilo, porque Rc es !Send:

// NO compila: `Rc<Vec<i32>>` no puede enviarse entre hilos con seguridad
// use std::rc::Rc;
// use std::thread;
// let dato = Rc::new(vec![1, 2, 3]);
// let d = Rc::clone(&dato);
// thread::spawn(move || println!("{d:?}")); // error: Rc no es Send

Cambiar Rc por Arc es todo lo que hace falta: la API es idéntica, la garantía no.

use std::sync::Arc;
use std::thread;

fn main() {
    let dato = Arc::new(vec![1, 2, 3]);
    let mut handles = vec![];
    for i in 0..3 {
        let d = Arc::clone(&dato);          // cada hilo recibe su participacion
        handles.push(thread::spawn(move || {
            println!("hilo {i} ve {d:?}");
        }));
    }
    for h in handles {
        h.join().unwrap();
    }
} // el ultimo hilo en terminar lleva la cuenta a 0 y libera el Vec

Cada hilo se lleva su propio Arc —su participación sobre el mismo Vec— y el último en terminar, sea cual sea, ejecuta la liberación. Nadie necesita saber quién será el último: el contador lo decide.

Por qué atómico

Los contadores de Arc son AtomicUsize, y los clone/drop los mueven con operaciones atómicas de incremento y decremento bajo un orden de memoria adecuado. Una operación atómica es indivisible: aunque dos hilos la ejecuten a la vez, el hardware garantiza que ninguna cuenta se pierde. Eso elimina de raíz la doble liberación, la liberación prematura y la fuga que un contador normal sufriría bajo concurrencia. Y eso —precisamente eso— es lo que autoriza al compilador a marcar Arc<T> como Send y Sync cuando T también lo es, mientras Rc se queda fuera.

flowchart TB
h1[Hilo 1] --> caja
h2[Hilo 2] --> caja
h3[Hilo 3] --> caja
subgraph caja[ArcInner en el heap]
  sc[contador atomico fuerte]
  wc[contador atomico debil]
  val[valor T compartido]
end
style h1 fill:#89b4fa,color:#11111b
style h2 fill:#89b4fa,color:#11111b
style h3 fill:#89b4fa,color:#11111b
style val fill:#a6e3a1,color:#11111b

El coste del trade-off

Nada de esto es gratis. Una operación atómica obliga a coordinar cachés entre núcleos y no puede reordenarse libremente, así que cuesta bastante más que sumar uno a un entero corriente. Clonar y soltar un mismo Arc en un bucle apretado desde varios hilos provoca ping-pong de la línea de caché que contiene el contador, y el rendimiento se hunde. De ahí la regla: usa Rc mientras estés dentro de un hilo y reserva Arc para cuando de verdad cruces la frontera. No cojas Arc “por si acaso”; pagas atomicidad por una seguridad que no necesitas.

Conviene separar dos cosas: leer el valor a través de un Arc es tan barato como con Rc —un Deref a &T, sin átomos—; lo atómico son solo las operaciones sobre el contador, es decir, clone y drop. Y, como Rc, Arc solo entrega &T: compartir entre hilos no te da mutación. Para mutar el dato compartido necesitas sincronización.

Arc con Mutex: el patrón del estado compartido

Arc resuelve quién posee; Mutex resuelve quién puede mutar ahora. Son ortogonales y se componen: Arc<Mutex<T>> es el patrón canónico del estado mutable compartido entre hilos.

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

fn main() {
    let contador = Arc::new(Mutex::new(0));
    let mut handles = vec![];
    for _ in 0..10 {
        let c = Arc::clone(&contador);
        handles.push(thread::spawn(move || {
            let mut n = c.lock().unwrap();   // adquiere el candado
            *n += 1;                         // mutacion exclusiva garantizada
        })); // al salir n, el candado se libera
    }
    for h in handles {
        h.join().unwrap();
    }
    println!("total = {}", *contador.lock().unwrap());  // 10
}

Arc permite que los diez hilos posean el mismo Mutex; el Mutex garantiza que solo uno mute a la vez. Sin el Arc no podrías repartir el Mutex entre los hilos; sin el Mutex no podrías mutar lo que el Arc comparte. Cada capa hace un trabajo, y su composición —que profundizarás en el nivel de estado compartido— es la respuesta idiomática de Rust a la mutación concurrente.