move y 'static: por qué el hilo debe poseer lo que toca

thread::spawn pide que su clausura sea Send + 'static, y ese 'static es la barrera con la que más pelea quien empieza con hilos. La tentación es leerlo como “vive para siempre” y concluir que los hilos solo aceptan datos eternos, lo cual sería absurdo. El significado real es más sutil y más profundo: un hilo hijo puede seguir corriendo cuando la función que lo lanzó ya retornó y liberó su pila, de modo que cualquier cosa que la clausura preste de esa pila se convertiría en un puntero a memoria muerta. 'static no exige que los datos vivan siempre; exige que no dependan de un préstamo que pueda caducar. Y la única forma de cumplir eso con variables locales es que el hilo las posea. Esa es la razón última de move.

El hilo puede sobrevivir a su cuna

Sin move, una clausura que solo lee captura por referencia. Dentro de un mismo ámbito eso es óptimo; a través de la frontera de un hilo es una catástrofe latente que el compilador ataja de raíz:

use std::thread;

fn main() {
    let datos = vec![10, 20, 30];

    let handle = thread::spawn(|| {
        println!("{datos:?}");   // ERROR: presta &datos, que no es 'static
    });

    handle.join().unwrap();
}

El compilador rechaza esto: “closure may outlive the current function, but it borrows datos”. El razonamiento es implacable. La clausura presta &datos, una referencia atada a la pila de main. Pero thread::spawn no promete que el hilo termine antes de que main retorne —de hecho, sin join podría seguir vivo indefinidamente—. Si main liberase datos mientras el hilo aún lo lee, tendríamos un uso tras liberación entre hilos: exactamente la clase de corrupción que Rust existe para impedir. El 'static del bound es lo que hace imposible ese escenario en tiempo de compilación.

Qué significa ’static de verdad

Aquí conviven dos usos de 'static que es vital no confundir:

• &'static T es una referencia cuyo destino vive durante todo el programa: un literal de cadena &'static str, o algo filtrado con Box::leak. La referencia en sí es eterna.
• T: 'static es una cota sobre un tipo: dice que T no contiene ninguna referencia con vida más corta que el programa. No dice que un valor de tipo T viva para siempre; dice que podría hacerlo sin volverse inválido, porque no arrastra ningún préstamo que caduque antes.

Esta segunda lectura es la que aparece en spawn, y es contraintuitiva: un String que creas y destruyes en la línea siguiente cumple String: 'static, porque posee sus bytes y no presta nada de nadie. En cambio &'a str para un 'a local no es 'static, porque su validez depende de un dueño que puede morir.

fn exige_static<T: 'static>(_x: T) {}

fn demo() {
    let s = String::from("efimero");
    exige_static(s);              // OK: String posee sus datos, es 'static

    let local = 42;
    let r: &i32 = &local;
    // exige_static(r);           // ERROR: &'a i32 depende de local, no es 'static

    let lit: &'static str = "vivo todo el programa";
    exige_static(lit);            // OK: la referencia ya es 'static
}

La regla mental: poseer un valor lo hace 'static; prestarlo de algo local, no. Por eso T: 'static no es una restricción sobre cuánto vive el valor, sino sobre de qué depende para seguir siendo válido. Un dato autónomo —que no toma prestado nada efímero— cumple la cota aunque su vida real dure un microsegundo.

move: convertir préstamos en posesión

move es la palabra que transforma cada captura por referencia en captura por valor. Aplicada a la clausura de un hilo, sustituye los préstamos de la pila del padre por posesiones que viajan con el hilo, y con ello la clausura pasa a cumplir 'static:

use std::thread;

fn main() {
    let datos = vec![10, 20, 30];

    let handle = thread::spawn(move || {
        // El hilo POSEE datos; no hay referencia a la pila de main.
        let suma: i32 = datos.iter().sum();
        println!("suma en el hilo: {suma}");
        suma
    });

    // datos ya no es accesible aqui: se movio al hilo.
    let total = handle.join().unwrap();
    println!("total recibido: {total}");
}

Al poseer datos, el hilo no depende del marco de main: cuando el hilo termine, liberará datos él mismo, sin importar qué haya sido de la pila del padre. La cota 'static queda satisfecha porque la clausura ya no presta nada efímero. Si necesitas conservar el original, el patrón es clonar antes de mover:

let datos = vec![10, 20, 30];
let copia = datos.clone();

let handle = thread::spawn(move || copia.iter().sum::<i32>());
println!("el padre aun ve {datos:?}");   // datos sigue vivo; se movio copia
let _ = handle.join();

Y el matiz que cierra el círculo: move no es un conjuro que borre referencias, solo cambia cómo se captura. Si mueves al hilo una referencia &'a T con 'a no estático, sigues incumpliendo 'static, porque lo que se movió es la referencia efímera misma. move satisface la cota únicamente cuando lo que captura son valores propios (o referencias que ya eran &'static). Poseer es la condición; move es solo el mecanismo que la activa.

flowchart TD
P[Hilo padre con datos en su pila] -->|spawn sin move presta la referencia| B[La clausura guarda un prestamo de la pila del padre]
B --> X[El padre retorna y libera datos]
X --> D[La referencia apuntaria a memoria muerta]
P -->|spawn con move mueve el valor| O[La clausura posee datos y viaja con el hilo]
O --> S[Cumple static porque no presta nada efimero]
style B fill:#f38ba8,color:#11111b
style D fill:#f38ba8,color:#11111b
style O fill:#a6e3a1,color:#11111b
style S fill:#89b4fa,color:#11111b