FerrousPath

Nivel 3 · Sistemas· Lección 1 de 11 · 30 min

Hilos y estado compartido

Concurrencia sin miedo — lanzar hilos, Send y Sync, canales, Mutex, RwLock e hilos con ámbito.

Lanzar hilos

use std::thread;

fn main() {
    let handles: Vec<_> = (0..4)
        .map(|id| {
            thread::spawn(move || {
                let sum: u64 = (0..1_000_000u64).map(|n| n * id).sum();
                (id, sum)
            })
        })
        .collect();

    for h in handles {
        let (id, sum) = h.join().unwrap(); // join devuelve Err si el hilo entró en pánico
        println!("thread {id}: {sum}");
    }
}

thread::spawn recibe una clausura y devuelve un JoinHandle. La clausura debe ser 'static y Send: el hilo nuevo puede sobrevivir a la función que lo lanzó, así que no puede tomar prestado de la pila de esa función; de ahí el move.

Send y Sync

La seguridad entre hilos de Rust viene de dos traits marcadores que el compilador implementa automáticamente:

  • Send: un valor de este tipo se puede mover a otro hilo.
  • Sync: un valor de este tipo se puede compartir entre hilos; formalmente, T: Sync si y solo si &T: Send.

Un tipo es Send/Sync si lo son todos sus campos. Las pocas excepciones son exactamente los tipos que no sería seguro compartir: Rc (contador no atómico), Cell y RefCell (mutabilidad interior sin sincronizar) y los punteros crudos.

use std::rc::Rc;
use std::thread;

fn main() {
    let data = Rc::new(5);
    let handle = thread::spawn(move || { // ❌ error[E0277]: `Rc<i32>` no se puede enviar entre hilos de forma segura
        println!("{data}");
    });
    handle.join().unwrap();
}

Ese es todo el truco. Una carrera de datos (data race) necesita dos hilos que accedan a la misma memoria, con al menos uno escribiendo y sin sincronización. Las reglas de préstamo prohíben la mutación con aliasing; Send y Sync extienden esas reglas entre hilos. El Rust seguro no puede tener carreras de datos. (Sí puede tener interbloqueos y condiciones de carrera lógicas, que no son errores de seguridad de memoria.)

Paso de mensajes

«No te comuniques compartiendo memoria; comparte memoria comunicándote.»

use std::sync::mpsc;
use std::thread;
use std::time::Duration;

fn main() {
    let (tx, rx) = mpsc::channel::<String>();

    for id in 0..3 {
        let tx = tx.clone();
        thread::spawn(move || {
            for step in 0..2 {
                thread::sleep(Duration::from_millis(10 * (id + 1)));
                tx.send(format!("worker {id} finished step {step}")).unwrap();
            }
        });
    }
    drop(tx); // libera el emisor original para que el bucle de abajo pueda terminar

    for message in rx {
        println!("{message}");
    }
}

mpsc significa multiple producer, single consumer (varios productores, un consumidor). send mueve el valor: una vez enviado, el emisor ya no puede tocarlo, así que no hay nada por lo que competir. El bucle receptor termina cuando se han liberado todos los emisores. Para colas acotadas con contrapresión usa mpsc::sync_channel(n); para canales con varios consumidores, el crate crossbeam-channel.

Estado compartido: Arc<Mutex<T>>

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

fn main() {
    let counter = Arc::new(Mutex::new(0u64));

    let handles: Vec<_> = (0..8)
        .map(|_| {
            let counter = Arc::clone(&counter);
            thread::spawn(move || {
                for _ in 0..10_000 {
                    let mut guard = counter.lock().unwrap();
                    *guard += 1;
                } // la guarda se libera → se suelta el cerrojo
            })
        })
        .collect();

    for h in handles {
        h.join().unwrap();
    }
    println!("{}", *counter.lock().unwrap());
}
  • Arc<T> es el Rc con conteo de referencias atómico: propiedad compartida entre hilos.
  • Mutex<T> contiene sus datos. lock() devuelve una guarda que se desreferencia a los datos y desbloquea al liberarse. No hay forma de llegar a los datos sin bloquear.
  • lock() devuelve un Result por el envenenamiento (poisoning): si un hilo entra en pánico mientras tiene el cerrojo, a los que bloqueen después se les avisa de que los datos pueden ser inconsistentes.

RwLock<T> permite muchos lectores o un escritor: otra vez la regla de préstamo, aplicada en tiempo de ejecución entre hilos. Para contadores y banderas simples, los atómicos (AtomicU64, AtomicBool) evitan por completo el bloqueo; el nivel 4 los trata con rigor.

Interbloqueo

Rust no impide los interbloqueos (deadlocks). La receta clásica: el hilo A bloquea x y después y; el hilo B bloquea y y después x. Defensas: adquirir siempre los cerrojos en un orden global consistente, mantenerlos el menor tiempo posible y no llamar nunca a código desconocido mientras tienes uno.

Hilos con ámbito

thread::scope garantiza que sus hilos se han unido (join) antes de retornar, así que sí pueden tomar prestado de la pila:

use std::thread;

fn main() {
    let data: Vec<u64> = (1..=1_000_000).collect();
    let chunks: Vec<&[u64]> = data.chunks(250_000).collect();

    let total: u64 = thread::scope(|s| {
        let handles: Vec<_> = chunks
            .iter()
            .map(|chunk| s.spawn(move || chunk.iter().sum::<u64>()))
            .collect();
        handles.into_iter().map(|h| h.join().unwrap()).sum()
    });

    println!("{total}");
}

Ni Arc ni clonaciones: el borrow checker puede ver que los hilos terminan antes que data.

Paralelismo de datos con Rayon

Para trabajo limitado por la CPU sobre colecciones, el crate rayon convierte un iterador en uno paralelo con un grupo de hilos que se roban trabajo entre sí (work stealing):

// crate: rayon
use rayon::prelude::*;

fn main() {
    let total: u64 = (1..=10_000_000u64)
        .into_par_iter()
        .filter(|n| n % 3 == 0)
        .map(|n| n * n % 1_000)
        .sum();
    println!("{total}");
}

Cambiar iter() por par_iter() es seguro por la misma razón que todo lo anterior: la clausura debe ser Send + Sync, y el compilador lo comprueba.

Ejercicios

  1. Calcula un HashMap de frecuencias de palabras sobre una cadena grande dividiéndola en cuatro partes con thread::scope, contando cada una en un hilo y fusionando los mapas.
  2. Construye una cadena con dos canales: un productor que envía números, un trabajador que los eleva al cuadrado y main que imprime los resultados.
  3. Escribe un programa que se interbloquee con dos mutex. Después arréglalo ordenando los cerrojos.
  4. Sustituye el contador Mutex<u64> por AtomicU64 y fetch_add(1, Ordering::Relaxed). Mide los dos.

Comprueba lo que has entendido

Elige una respuesta para ver la explicación.

  1. 1.¿Por qué no se puede enviar un Rc<T> a otro hilo?

  2. 2.¿Qué significa T: Sync?

  3. 3.¿En qué se diferencia Mutex<T> en Rust de un mutex en C?

Términos clave de esta lección

¿Has terminado la lección y los ejercicios?