Rust tiene la filosofía de "concurrencia sin miedo"; lo cual te permitirá escribir código libre de errores sutiles y fácil de refactorizar.
Rust ofrece una variedad de herramientas para modelar problemas de la manera que sea más apropiada para su situación y requisitos.
Entre ellas tenemos:
- Creación de hilos(threads) para ejecutar múltiples fragmentos de código simultáneamente.
- Concurrencia mediante paso de mensajes, donde los canales envían mensajes entre hilos.
- Concurrencia de estado compartido, donde múltiples hilos tienen acceso a un mismo dato.
- Los traits `Sync` y `Send`, que extienden las garantías de concurrencia de Rust a tipos definidos por el usuario, así como a tipos proporcionados por la biblioteca estándar.
Rust garantiza que solo un hilo puede modificar datos a la vez, o que múltiples hilos pueden leerlos sin riesgo.
Si intentas compartir datos de forma insegura, el compilador no te dejará compilar. Cada hilo de Rust corresponde a un hilo del sistema operativo, lo que simplifica la gestión.
Pero antes de hacer nada, ¿Qué es la programación concurrente (si es que existe ese paradigma)?
Empecemos definiendo qué es la concurrencia:
Es la capacidad de un sistema para gestionar múltiples tareas simultáneamente, estructurando el código para que partes independientes progresen en el mismo periodo de tiempo, sin necesidad de ejecutarse en paralelo.
Tiene más relación a la buena gestión de recursos y no tanto a la rapidez con la que acaba un proceso.
Se implementa mediante hilos (threads), los cuales son unidades ligeras de ejecución dentro de un mismo proceso compartiendo memoria. Además éstos pueden ejecutarse en distinto orden sin afectar el resultado final.
La concurrencia no es lo mismo que el paralelismo; la concurrencia trata sobre gestionar múltiples tareas a la vez, mientras que el paralelismo trata sobre ejecutar múltiples tareas a la vez. Un programa puede ser concurrente incluso en un solo procesador intercalando tareas.
La concurrencia introduce desafíos como el determinismo, donde el orden de finalización no es fijo, y problemas de sincronización al compartir recursos.
Teniendo esto claro, pasemos a lo que es la programación concurrente:
Se refirere a un paradigma de software donde múltiples tareas o procesos avanzan simultáneamente durante el mismo período de tiempo. No implica necesariamente que corran al mismo tiempo en diferentes núcleos (paralelismo), sino que se gestionan de forma intercalada para maximizar la eficiencia y mejorar la capacidad de respuesta, gestionando la comunicación y sincronización entre hilos (threads).
Cabe aclarar que:
no implica necesariamente que corran (los hilos) al mismo tiempo en diferentes núcleos (paralelismo), sino que se gestionan de forma intercalada para maximizar la eficiencia y mejorar la capacidad de respuesta, gestionando la comunicación y sincronización entre hilos (threads).
Para quien haya programado interfaces gráficas con Java Swing sabrá que muchas aplicaciones quedaban "trabada" o "congeladas" cuando el usuario trataba de realizar varias cosas a la vez y es ahí donde ocurre la magia, pues:
La programación concurrente nos ayuda a mejorar la eficiencia del sistema, reduce los tiempos de espera y optimiza el uso de recursos computacionales.
Otro detalle a tomar en cuenta, en Rust (y lenguajes como Java), los hilos estándar (std::thread) son gestionados directamente por el sistema operativo.
Rust denomina su enfoque "concurrencia sin miedo" porque gracias a su sistema de ownership y tipos, muchos errores de concurrencia se detectan en tiempo de compilación en lugar de aparecer como fallos en ejecución. Esto permite escribir programas concurrentes seguros y eficientes sin los típicos problemas de race conditions o deadlocks.
Rust ofrece herramientas como thread::spawn, Arc, Mutex y canales para implementar concurrencia segura, y el compilador actúa como guardián para que los errores comunes de otros lenguajes no lleguen a producción.
Ahora basta de teoría y pasemos a la acción.
Concurrencia sin miedo
Ejemplo 1. Crearemos un programa que imprima un texto desde el hilo principal y otro texto desde el nuevo hilo.
main.s
use std::thread; use std::time::Duration; fn main() { thread::spawn(|| { for i in 1..10 { println!("Hola numero {i} desde el hilo esclavo!"); thread::sleep(Duration::from_millis(1)); } }); for i in 1..5 { println!("Hola numero {i} desde el hilo principal!"); thread::sleep(Duration::from_millis(1)); } }
Construimos y ejecutamos:
$ cargo build $ cargo run
Salida:
Hola numero 1 desde el hilo principal! Hola numero 1 desde el hilo esclavo! Hola numero 2 desde el hilo principal! Hola numero 2 desde el hilo esclavo! Hola numero 3 desde el hilo principal! Hola numero 3 desde el hilo esclavo! Hola numero 4 desde el hilo principal! Hola numero 4 desde el hilo esclavo! Hola numero 5 desde el hilo esclavo!
En este programa creamos un hilo principal y uno "esclavo" que imprime un mensaje de "Hola número X" con un sleep de 1 milisegundo.
Ejemplo 2. Creamos otro programa. En el cual obligamos a manejar la propiedad de los datos compartidos entre hilos.
main.rs
use std::thread; fn main() { let handle = thread::spawn(|| { for i in 1..5 { println!("Hola desde el hilo: {}", i); } }); for j in 1..5 { println!("Hola desde main: {}", j); } handle.join().unwrap(); }
Donde:
- thread::spawn crea un nuevo hilo.
- join() asegura que el hilo secundario termine antes de que el programa finalice.
Construimos y ejecutamos:
$ cargo build $ cargo run
Salida:
Hola desde main: 1 Hola desde main: 2 Hola desde el hilo: 1 Hola desde el hilo: 2 Hola desde main: 3 Hola desde el hilo: 3 Hola desde el hilo: 4 Hola desde main: 4
Ejemplo 3. Ahora un ejemplo de compartir datos usando Arc y Mutex.
main.r
use std::sync::{Arc, Mutex}; use std::thread; fn main() { let contador = Arc::new(Mutex::new(0)); let mut handles = vec![]; for _ in 0..10 { let contador_clon = Arc::clone(&contador); let handle = thread::spawn(move || { let mut num = contador_clon.lock().unwrap(); *num += 1; }); handles.push(handle); } for h in handles { h.join().unwrap(); } println!("Resultado: {}", *contador.lock().unwrap()); }
En este programa podemos observar que:
- Arc (Atomic Reference Counted): Permite compartir datos entre hilos de forma segura.
- Mutex: Garantiza acceso exclusivo a los datos, evitando condiciones de carrera. Resultado esperado: 10, ya que cada hilo incrementa el contador.
Construimos y ejecutamos:
$ cargo build $ cargo run
Salida:
Resultado: 10
Ejemplo 4. Crear canales para comunicación entre hilos.
main.rs
use std::sync::mpsc; use std::thread; fn main() { let (tx, rx) = mpsc::channel(); thread::spawn(move || { tx.send("Mensaje desde el hilo").unwrap(); }); let recibido = rx.recv().unwrap(); println!("Recibido: {}", recibido); }
En este programa podemos ver que:
- mpsc::channel: Crea un canal de comunicación entre hilos.
- El compilador garantiza que los datos enviados cumplen las reglas de propiedad.
Construimos y ejecutamos:
$ cargo build $ cargo run
Salida:
Recibido: Mensaje desde el hilo
Después de todo lo visto, debemos tomar en cuenta que:
Los hilos en Rust son ligeros y se integran directamente con el sistema operativo. Permite aprovechar múltiples núcleos de CPU sin sacrificar estabilidad.
Rust permite crear aplicaciones que manejan miles de tareas concurrentes sin que el consumo de memoria se dispare. Ideal para sistemas distribuidos, microservicios y aplicaciones de red.
Rust nos da la capacidad de escribir software concurrente rápido, seguro y escalable, reduciendo el miedo a los errores clásicos de concurrencia.
En próximas entregas veremos más sobre la programación concurrente en Rust.
Enlaces:
https://doc.rust-lang.org/book/ch16-00-concurrency.htmlhttps://doc.rust-lang.org/book/ch16-01-threads.html
https://www.reddit.com/r/rust/comments/y0ytw8/process_and_thread/
https://stevedonovan.github.io/rust-gentle-intro/7-shared-and-networking.html
https://www.programiz.com/rust/thread
Comentarios
Publicar un comentario