Saltar al contenido

Lección 12 de 24 · Lectura y práctica

Proyecto: Sistema de Procesamiento Concurrente

Tipo de lección: VideoConcepto claveEn sistemas de baja latencia y alta seguridad, la concurrencia no es solo un mecanismo para mejorar el rendimiento, sino una herramienta para garantizar la predictibilidad y la aislación de.

Del concepto a la práctica

Taller de esta lección

Un proyecto concurrente pequeño debe tener una propiedad comprobable: cada entrada produce como máximo un resultado y el cierre no pierde mensajes. Usa identificadores para reconstruir la correspondencia, en lugar de confiar en el orden de llegada de varios workers.

Ejemplo resuelto

rust
use std::sync::mpsc;
use std::thread;
fn main() {
    let (tx, rx) = mpsc::channel();
    for (id, valor) in [(1, 3), (2, 4)] {
        let tx = tx.clone();
        thread::spawn(move || tx.send((id, valor * 2)).unwrap());
    }
    drop(tx);
    let mut r: Vec<_> = rx.into_iter().collect();
    r.sort_by_key(|x| x.0);
    println!("{:?}", r);
}

La salida esperada es [(1, 6), (2, 8)].

Pruébalo

  1. Añade la entrada (3,5).

  2. Cierra el remitente principal.

  3. Recoge todos los resultados.

  4. Ordena solo para verificar.

Comprueba tu resultado

Error frecuente: asumir que la llegada concurrente conserva el orden de entrada. Corrección: incluye id y ordena únicamente al presentar.

Ejercicio: con tres entradas, el resultado esperado ordenado es [(1,6),(2,8),(3,10)]; verifica que hay exactamente tres resultados.

Workers observados y un canal acotado

rust
use std::sync::mpsc;
use std::thread;
fn main() {
    let (tx, rx) = mpsc::sync_channel(2);
    let entradas = [(1, 3), (2, 4), (3, 5)];
    let mut handles = Vec::new();
    for bloque in [entradas[..2].to_vec(), entradas[2..].to_vec()] {
        let copia = tx.clone();
        handles.push(thread::spawn(move || {
            for (id, valor) in bloque { copia.send((id, valor * 2)).unwrap(); }
        }));
    }
    drop(tx);
    let mut resultados: Vec<_> = rx.into_iter().collect();
    for h in handles { h.join().unwrap(); }
    resultados.sort_by_key(|r| r.0);
    assert_eq!(resultados, vec![(1,6), (2,8), (3,10)]);
}

Son dos threads y tres entradas fijas, no un thread por cada evento ilimitado. El coordinador recibe antes de hacer join para dejar avanzar send con backpressure. Cada handle se observa; errores de worker y mensajes ausentes deben causar un fallo de la prueba, en vez de ocultarse al cerrar el canal.

Diagrama de decisión con ramas Sí y No y un bucle que procesa cada elemento de una lista.
CursaloMapa de práctica
Cómo avanza un programa

Una condición decide qué camino ejecuta el programa. Un bucle repite una operación mientras queden elementos, y termina cuando la lista se agota. Separar ambas ideas ayuda a seguir el flujo y comprobar casos límite.

Ver la infografía en tamaño completo ↗
Fuentes para profundizar

Tipo de lección: Video

Concepto clave

En sistemas de baja latencia y alta seguridad, la concurrencia no es solo un mecanismo para mejorar el rendimiento, sino una herramienta para garantizar la predictibilidad y la aislación de fallos. Rust implementa concurrencia a través de su sistema de propiedad y tipos como Arc, Mutex, y canales (mpsc), que eliminan data races en tiempo de compilación. Esto es crucial en sistemas críticos donde un error de concurrencia puede causar latencias inesperadas o vulnerabilidades de seguridad.

Una analogía del mundo real es un sistema de control de tráfico aéreo: múltiples aviones (hilos) deben compartir espacio aéreo (recursos) sin colisionar (data races). Rust actúa como el controlador que verifica las reglas antes de permitir cualquier operación, asegurando que cada avión mantenga una trayectoria segura y predecible.

Cómo funciona en la práctica

Vamos a construir un sistema de procesamiento concurrente para transacciones financieras, donde la latencia y la seguridad son críticas. El sistema debe procesar múltiples transacciones en paralelo, validar cada una, y registrar resultados sin bloqueos innecesarios.

Paso 1: Definir la estructura de datos compartida usando Arc>> para garantizar acceso seguro.

Paso 2: Crear hilos con std::thread::spawn que tomen transacciones de una cola concurrente.

Paso 3: Implementar validación en cada hilo, usando match para manejar errores sin panics.

Paso 4: Usar canales (mpsc::channel) para comunicar resultados entre hilos, minimizando el uso de mutexes.

Paso 5: Medir latencias con std::time::Instant para asegurar que se cumplan los requisitos de performance.

Caso de estudio

Considera un sistema de trading de alta frecuencia que procesa 10,000 órdenes por segundo. Cada orden debe ser validada (chequeo de saldo, límites de riesgo) y ejecutada en menos de 100 microsegundos. En Rust, se implementa así:

  • Se usa un pool de hilos (rayon o tokio para I/O asíncrono) para paralelizar la validación.
  • Los datos de cuenta se almacenan en un DashMap para acceso concurrente sin bloqueos globales.
  • Las órdenes se envían a través de canales a un hilo dedicado de ejecución, que garantiza ordenamiento y registro atómico.

Resultados típicos en una máquina con 8 núcleos:

MétricaValor
Latencia promedio85 μs
Throughput máximo12,000 órdenes/seg
Uso de CPU70%
En sistemas críticos, la elección entre mutexes y canales depende del patrón de acceso: usa canales para comunicación y mutexes para estado compartido complejo.

Errores comunes

  1. Deadlocks por orden incorrecto de locks: Al adquirir múltiples mutexes, siempre usa un orden fijo (ej., por ID de recurso) para evitar deadlocks.
  2. Abuso de Arc: No uses Arc para datos que no necesitan compartirse; incrementa overhead de memoria y sincronización.
  3. Ignorar el costo de sincronización: Mutexes y canales añaden latencia; perfila con herramientas como criterion para optimizar.
  4. No manejar panics en hilos: Usa catch_unwind o canales para propagar errores en lugar de causar crashes.
  5. Subutilizar paralelismo de datos: Para procesamiento puro, prefiere rayon::par_iter sobre hilos manuales para mejor escalabilidad.

Checklist de dominio

  • ¿Puedes implementar un sistema con 10+ hilos que procese datos sin data races?
  • ¿Sabes cuándo usar Mutex vs RwLock vs canales?
  • ¿Mides latencias y throughput en tus implementaciones concurrentes?
  • ¿Entiendes cómo el sistema de tipos de Rust previene condiciones de carrera?
  • ¿Puedes debuggear deadlocks usando herramientas como gdb o logs?
  • ¿Implementas timeouts en operaciones concurrentes para evitar bloqueos indefinidos?
  • ¿Conoces los trade-offs entre concurrencia con hilos y async/await para I/O?

Sistema de Procesamiento de Transacciones Concurrente

Implementa un sistema en Rust que procese transacciones financieras de forma concurrente, cumpliendo con requisitos de baja latencia y alta seguridad.

  1. Crea una estructura Transaction con campos: id: u32, amount: f64, account_id: u32.
  2. Genera 1,000 transacciones aleatorias (IDs únicos, montos entre 1.0 y 1000.0).
  3. Implementa un validador concurrente que verifique: monto positivo y account_id existente (usa un HashSet compartido de cuentas válidas).
  4. Usa 4 hilos para procesar las transacciones, tomándolas de una cola segura (Arc>>).
  5. Cada hilo debe registrar transacciones válidas en un Vec compartido y las inválidas en otro, con timestamps de Instant.
  6. Al final, calcula y muestra: latencia promedio de procesamiento, throughput (transacciones/segundo), y porcentaje de válidas.
  7. Asegúrate de que no haya data races (compila sin warnings de concurrencia).
Pistas
  • Usa Arc::clone para compartir datos entre hilos, no references crudas.
  • Considera usar crossbeam::channel para una cola más eficiente que Mutex.
  • Perfila con #[bench] o criterion para optimizar el número de hilos.

Evalua tu comprension

Completa el quiz interactivo de arriba para ganar XP.

Sigue con Rust para Trading: Concurrencia, Seguridad y Baja Latencia

Esta lección forma parte de un curso de Cursalo. Revisa su programa y elige entre la compra individual o el acceso a toda la escuela.

Si ya tenías acceso a este curso, entra con tu cuenta: tus derechos y tu progreso se conservan. No necesitas comprarlo de nuevo.

01 / ELEGIR UNA RUTA

El próximo paso

Aprende IA mientras construyes algo que sí necesitas.

Empieza por el curso inicial o explora el catálogo para encontrar una práctica alineada con tu trabajo.