Crear hilos
Ejecute código de forma concurrente
Crear hilos es una lección gratuita de Learn Rust Coding en CoddyKit. Esta es la lección 1 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Learn Rust Coding, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Learn Rust Coding incluye 4 lecciones en total.
¿Qué es un thread?
Un thread permite que su programa ejecute código de forma concurrente. El sistema operativo puede planificar varios threads, por lo que el trabajo puede solaparse.
La biblioteca estándar de Rust expone los threads mediante el módulo std::thread. Son threads nativos del sistema operativo, a veces llamados threads 1:1.
En esta lección aprenderá a iniciar nuevos threads y a controlar cómo se ejecutan.
Crear threads con thread::spawn
Puede crear un thread nuevo llamando a thread::spawn y pasándole una closure. La closure contiene el código que ejecutará el nuevo thread.
La llamada devuelve inmediatamente un JoinHandle, mientras el thread creado se ejecuta en segundo plano.
use std::thread;
fn main() {
thread::spawn(|| {
println!("hello from a thread");
});
println!("hello from main");
}main puede terminar primero
Cuando main devuelve el control, termina todo el proceso, aunque todavía haya threads creados en ejecución.
Por eso, el programa anterior podría imprimir únicamente el mensaje principal. Es posible que el thread en segundo plano no tenga oportunidad de ejecutarse antes de que finalice el proceso.
Necesitamos una forma de esperar a que terminen los threads.
Esperar con join
El JoinHandle devuelto por spawn tiene un método join. Al llamarlo, se bloquea el thread actual hasta que termina el thread creado.
Esto garantiza que el thread creado se ejecute hasta completarse antes de que main continúe.
use std::thread;
fn main() {
let handle = thread::spawn(|| {
println!("worker done");
});
handle.join().unwrap();
println!("main done");
}Salida intercalada
Cuando se ejecutan dos hilos a la vez, su salida puede intercalarse de formas impredecibles. El sistema operativo decide la planificación.
Ejecutar el mismo programa dos veces puede producir órdenes diferentes. Nunca dependa de un orden específico sin sincronización.
use std::thread;
fn main() {
let handle = thread::spawn(|| {
for i in 1..4 {
println!("thread: {}", i);
}
});
for i in 1..4 {
println!("main: {}", i);
}
handle.join().unwrap();
}Pausar con sleep
Puede pausar un hilo con thread::sleep, que recibe un Duration. Esto cede la CPU para que otros hilos puedan avanzar.
Suspender la ejecución resulta útil en ejemplos para hacer más visible la intercalación, pero evítelo para la sincronización real.
use std::thread;
use std::time::Duration;
fn main() {
thread::spawn(|| {
for i in 1..4 {
println!("spawned: {}", i);
thread::sleep(Duration::from_millis(1));
}
});
thread::sleep(Duration::from_millis(10));
}Crear muchos hilos
Puede crear varios hilos en un bucle y recopilar sus handles en un vector.
Después puede iterar sobre el vector y hacer join de cada handle, garantizando que todos los hilos terminen antes de que finalice el programa.
use std::thread;
fn main() {
let mut handles = vec![];
for id in 0..3 {
let h = thread::spawn(move || {
println!("thread {}", id);
});
handles.push(h);
}
for h in handles {
h.join().unwrap();
}
}Nombrar hilos con Builder
El tipo thread::Builder permite configurar un hilo antes de crearlo. Puede establecer un nombre y un tamaño de pila.
Los hilos con nombre facilitan la lectura de los mensajes de panic y la depuración.
use std::thread;
fn main() {
let h = thread::Builder::new()
.name("worker".into())
.spawn(|| {
println!("running in named thread");
})
.unwrap();
h.join().unwrap();
}Los panic permanecen en el hilo
Si un hilo creado produce un panic, de forma predeterminada no bloquea todo el programa. El panic queda contenido en ese hilo.
Cuando llama a join sobre un hilo que ha producido un panic, obtiene un Err. Esto permite que el padre detecte el fallo.
use std::thread;
fn main() {
let h = thread::spawn(|| {
panic!("boom");
});
let result = h.join();
println!("joined, is_err = {}", result.is_err());
}Información del hilo actual
Puede inspeccionar el hilo en ejecución con thread::current. Devuelve un handle cuyo método name proporciona el nombre opcional del hilo.
El hilo principal también es un hilo real y normalmente se llama main.
use std::thread;
fn main() {
let current = thread::current();
println!("name: {:?}", current.name());
}Devolver valores desde los hilos
El closure que se pasa a spawn puede devolver un valor. Ese valor vuelve envuelto en Ok cuando llama a join.
Es una forma sencilla de calcular algo en otro hilo y leer el resultado más adelante.
use std::thread;
fn main() {
let h = thread::spawn(|| {
let sum: i32 = (1..=10).sum();
sum
});
let total = h.join().unwrap();
println!("total = {}", total);
}Comprobación rápida
Compruebe su comprensión de la creación de hilos.
Resumen
Ha aprendido a iniciar hilos con thread::spawn y un closure, que devuelve un JoinHandle.
Llamar a join espera a que termine la ejecución y proporciona el valor devuelto o un panic. La salida de los hilos puede intercalarse de formas impredecibles, y Builder permite asignar nombres a los hilos.
A continuación verá cómo mover datos a los hilos que crea.
Aprende Rust con un tutor de IA — gratis
Escribe y ejecuta código real en tu navegador, obtén ayuda instantánea de un tutor de IA disponible 24/7 y continúa donde lo dejaste en la web o en la aplicación.
- Cursos
- 39
- Lecciones
- 144
Preguntas frecuentes
¿La lección «Crear hilos» es gratis?
Sí — el texto completo de «Crear hilos» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Learn Rust Coding, actualiza a CoddyKit PRO. El curso de Learn Rust Coding incluye 4 lecciones en total.
¿Qué aprenderé en «Crear hilos»?
Ejecute código de forma concurrente Practicas Learn Rust Coding con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar Learn Rust Coding?
No se requiere experiencia previa. Learn Rust Coding en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 4.
¿Cuánto tiempo toma la lección «Crear hilos»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de Learn Rust Coding?
Sí. Cada lección de Learn Rust Coding incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.