El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

Hilos

Siguiente ►
►

En este módulo, aprenderemos sobre la concurrencia en Rust, específicamente sobre el uso de hilos. La concurrencia permite que múltiples tareas se ejecuten simultáneamente, lo que puede mejorar el rendimiento de los programas. Rust proporciona una forma segura y eficiente de trabajar con hilos.

Conceptos Clave

  1. Hilos: Un hilo es una unidad de ejecución dentro de un proceso. Los hilos permiten que un programa realice múltiples tareas al mismo tiempo.
  2. Concurrencia: La capacidad de un programa para hacer múltiples cosas a la vez.
  3. Seguridad en la concurrencia: Rust garantiza la seguridad en la concurrencia mediante su sistema de propiedad y préstamo.

Creación de Hilos

En Rust, podemos crear hilos utilizando la función thread::spawn. Aquí hay un ejemplo básico:

use std::thread;
use std::time::Duration;

fn main() {
    let handle = thread::spawn(|| {
        for i in 1..10 {
            println!("Hola desde el hilo secundario: {}", i);
            thread::sleep(Duration::from_millis(1));
        }
    });

    for i in 1..5 {
        println!("Hola desde el hilo principal: {}", i);
        thread::sleep(Duration::from_millis(1));
    }

    handle.join().unwrap();
}

Explicación del Código

  1. Importación de Módulos: Importamos el módulo thread y time::Duration.
  2. Creación de un Hilo: Utilizamos thread::spawn para crear un nuevo hilo. La función spawn toma una clausura (closure) que define el trabajo que el hilo realizará.
  3. Hilo Principal: El hilo principal continúa ejecutándose mientras el hilo secundario también está en ejecución.
  4. Sincronización de Hilos: Utilizamos handle.join().unwrap() para esperar a que el hilo secundario termine antes de que el hilo principal continúe.

Ejercicio Práctico

Ejercicio 1: Crear y Sincronizar Hilos

Objetivo: Crear dos hilos adicionales además del hilo principal y sincronizarlos.

Instrucciones:

  1. Crea dos hilos adicionales utilizando thread::spawn.
  2. Cada hilo debe imprimir un mensaje diferente.
  3. Asegúrate de que el hilo principal espere a que ambos hilos secundarios terminen antes de finalizar.

Código Inicial:

use std::thread;
use std::time::Duration;

fn main() {
    // Crear el primer hilo
    let handle1 = thread::spawn(|| {
        for i in 1..5 {
            println!("Mensaje desde el primer hilo: {}", i);
            thread::sleep(Duration::from_millis(1));
        }
    });

    // Crear el segundo hilo
    let handle2 = thread::spawn(|| {
        for i in 1..5 {
            println!("Mensaje desde el segundo hilo: {}", i);
            thread::sleep(Duration::from_millis(1));
        }
    });

    // Hilo principal
    for i in 1..3 {
        println!("Mensaje desde el hilo principal: {}", i);
        thread::sleep(Duration::from_millis(1));
    }

    // Esperar a que ambos hilos terminen
    handle1.join().unwrap();
    handle2.join().unwrap();
}

Solución

use std::thread;
use std::time::Duration;

fn main() {
    // Crear el primer hilo
    let handle1 = thread::spawn(|| {
        for i in 1..5 {
            println!("Mensaje desde el primer hilo: {}", i);
            thread::sleep(Duration::from_millis(1));
        }
    });

    // Crear el segundo hilo
    let handle2 = thread::spawn(|| {
        for i in 1..5 {
            println!("Mensaje desde el segundo hilo: {}", i);
            thread::sleep(Duration::from_millis(1));
        }
    });

    // Hilo principal
    for i in 1..3 {
        println!("Mensaje desde el hilo principal: {}", i);
        thread::sleep(Duration::from_millis(1));
    }

    // Esperar a que ambos hilos terminen
    handle1.join().unwrap();
    handle2.join().unwrap();
}

Errores Comunes y Consejos

  1. No Sincronizar Hilos: Olvidar llamar a join en los manejadores de hilos puede causar que el hilo principal termine antes de que los hilos secundarios hayan completado su trabajo.
  2. Acceso Concurrente a Datos: Asegúrate de manejar correctamente el acceso concurrente a datos compartidos utilizando mecanismos de sincronización como Mutex o Arc.

Resumen

En esta sección, hemos aprendido cómo crear y sincronizar hilos en Rust. La concurrencia es una herramienta poderosa que puede mejorar el rendimiento de nuestros programas, pero también requiere una gestión cuidadosa para evitar errores comunes. En el próximo tema, exploraremos el paso de mensajes entre hilos para una comunicación segura y eficiente.

◄ Anterior
◄
Siguiente ►
►
El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2024. Todos los derechos reservados