Problema con la implementación de threads en Rust

Publicado por Brisa
hace 9 meses

¡Hola comunidad!

Soy una programadora en busca de ayuda para solucionar un problema con la implementación de threads en Rust. Estoy intentando crear múltiples threads para mejorar la eficiencia de mi programa, pero parece que algo no estoy haciendo bien.

Mi objetivo es crear dos threads que ejecuten funciones diferentes al mismo tiempo. Aquí está mi código:

use std::thread;

fn main() {
    let thread1 = thread::spawn(|| {
        for i in 1..=5 {
            println!("Thread 1: {}", i);
        }
    });

    let thread2 = thread::spawn(|| {
        for i in 6..=10 {
            println!("Thread 2: {}", i);
        }
    });

    thread1.join().unwrap();
    thread2.join().unwrap();
}

El problema es que cuando ejecuto mi programa, solo obtengo la salida del primer Thread y luego se detiene. Pareciera que no se está ejecutando el segundo Thread.

¿Alguien tiene alguna idea de lo que estoy haciendo mal? ¿Existe alguna forma de corregir esto y lograr que ambos Threads se ejecuten correctamente? Espero que alguien pueda ayudarme a resolver este problema, ¡se los agradecería mucho!

Aquí está el error que estoy obteniendo al ejecutar el código:

Thread 1: 1
Thread 1: 2
Thread 1: 3
Thread 1: 4
Thread 1: 5

¡Gracias de antemano!

Rust threads problema

Compartir en

Respuesta de Gordon Shumway
hace 9 meses

¡Hola Brisa!

Tu código parece estar bien para la creación de dos threads y el objetivo de ejecutar dos funciones diferentes de manera concurrente. No deberías estar teniendo el problema que mencionas si tu sistema está funcionando normalmente. Cada vez que ejecutas el programa, el orden en que los threads se ejecutan puede variar debido a la planificación de threads del sistema operativo.

Si solo ves la salida del primer thread, una posible explicación es que al ejecutar tu programa, el thread principal pueda estar terminando antes de que el segundo thread comience a ejecutarse, aunque en este caso, el método join() debería prevenir ese comportamiento, asegurando que el hilo principal espera a que ambos threads hijos hayan terminado.

Aquí hay algunas sugerencias y puntos para verificar:

Asegúrate de que ambos threads tienen la oportunidad de ejecutarse. Verifica el uso de la CPU y otros procesos del sistema que podrían estar afectando la ejecución de tu aplicación.
Puede haber algún tipo de salida intermedia que no estés viendo. Intenta ejecutar el programa en diferentes entornos (por ejemplo, diferentes terminales o sistemas operativos) para ver si hay alguna diferencia.
Asegúrate de que no hay errores ocultos que puedan ser silenciados. Aunque en tu ejemplo no parece haber espacio para ninguno.

Dado que tu código es correcto y debería funcionar, aquí hay un par de modificaciones para forzar una salida más "intercalada", agregando algún retardo:

use std::{thread, time};

fn main() {
    let thread1 = thread::spawn(|| {
        for i in 1..=5 {
            println!("Thread 1: {}", i);
            thread::sleep(time::Duration::from_millis(10));
        }
    });

    let thread2 = thread::spawn(|| {
        for i in 6..=10 {
            println!("Thread 2: {}", i);
            thread::sleep(time::Duration::from_millis(10));
        }
    });

    thread1.join().unwrap();
    thread2.join().unwrap();
}

Si aún sigues experimentando el mismo problema después de verificar estas sugerencias, te recomendaría inspeccionar la configuración del sistema o buscar problemas específicos en tu entorno de desarrollo que puedan estar interfiriendo con la ejecución de threads.

Espero que esto ayude y puedas ver la ejecución intercalada de ambos threads como esperas. ¡Mucho éxito!