Saltar al contenido

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

Quiz: Concurrencia y Paralelismo

Tipo de lección: QuizConcepto claveEn sistemas de baja latencia y alta seguridad, la concurrencia y el paralelismo no son solo optimizaciones de rendimiento, sino garantías de corrección y predictibilidad. La concurrencia se.

Del concepto a la práctica

Taller de esta lección

La diferencia se puede comprobar con un escenario concreto. Tres tareas concurrentes pueden turnarse en un solo hilo mientras esperan; tres tareas paralelas ejecutan trabajo al mismo tiempo en recursos separados. Un canal ordena comunicación, pero no demuestra paralelismo. La métrica debe indicar qué parte fue simultánea y qué parte solo estuvo intercalada.

Ejemplo resuelto

rust
fn clasificar(hilos: usize, tareas: usize) -> &'static str {
    if hilos > 1 && tareas > 1 { "posible paralelismo" } else if tareas > 1 { "concurrencia" } else { "sin evidencia de concurrencia" }
}
fn main() { println!("{}", clasificar(2, 3)); }

La salida es posible paralelismo; la palabra “posible” evita confundir configuración con evidencia.

Pruébalo

  1. Evalúa clasificar(1,3).

  2. Evalúa clasificar(2,1).

  3. Mide trabajo real si usas varios hilos.

  4. Busca bloqueos y colas sin límite.

Comprueba tu resultado

Error frecuente: concluir paralelismo solo porque existe más de un hilo. Corrección: demostrar ejecución simultánea o declarar que solo es una posibilidad.

Ejercicio: las entradas (1,3), (2,1) y (2,3) deben devolver concurrencia, sin evidencia de concurrencia y posible paralelismo.

Con una tarea y dos hilos no demuestras concurrencia entre tareas; el número de hilos disponible tampoco demuestra simultaneidad. Añade el caso tareas=0 como sin trabajo y rechaza una configuración con hilos=0 antes de usar esta función didáctica. El programa etiqueta una posibilidad, no mide scheduling ni ejecución paralela real.

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: Quiz

Concepto clave

En sistemas de baja latencia y alta seguridad, la concurrencia y el paralelismo no son solo optimizaciones de rendimiento, sino garantías de corrección y predictibilidad. La concurrencia se refiere a la capacidad de un sistema para manejar múltiples tareas aparentemente simultáneas, aunque puedan ejecutarse intercaladas en un solo núcleo, mientras que el paralelismo implica ejecutar tareas realmente al mismo tiempo en múltiples núcleos. En Rust, esto se gestiona a través de su sistema de propiedad y tipos como Arc, Mutex, y canales (mpsc), que previenen condiciones de carrera y garantizan seguridad en la memoria sin necesidad de un recolector de basura.

Una analogía del mundo real: imagina un controlador de tráfico aéreo (concurrencia) que coordina múltiples aviones en una pista única, asegurando que no colisionen mediante reglas estrictas, versus múltiples pistas (paralelismo) donde los aviones despegan simultáneamente. En sistemas críticos, como transacciones financieras de alta frecuencia, un error en la coordinación puede resultar en pérdidas millonarias o brechas de seguridad, por lo que Rust proporciona herramientas para modelar estos escenarios de forma segura en tiempo de compilación.

Cómo funciona en la práctica

En Rust, la concurrencia y el paralelismo se implementan usando hilos (std::thread) y tipos de sincronización. Por ejemplo, para procesar datos de sensores en tiempo real en un sistema de seguridad, podrías usar canales para comunicar entre hilos sin compartir estado mutable. Aquí un ejemplo paso a paso:

  1. Crea un canal con mpsc::channel() para enviar datos entre un productor y un consumidor.
  2. En el hilo productor, usa sender.send(data) para enviar lecturas de sensor.
  3. En el hilo consumidor, usa receiver.recv() para procesar los datos, aplicando lógica de validación.
  4. Usa Arc<Mutex<T>> si necesitas compartir estado mutable entre hilos, como un contador de eventos críticos.

Este enfoque minimiza la latencia al evitar bloqueos innecesarios y garantiza que los datos no se corrompan, clave para sistemas como monitoreo de red o procesamiento de transacciones.

Caso de estudio

Considera un sistema de trading de alta frecuencia que procesa órdenes de compra/venta en microsegundos. En este caso, se usa paralelismo para analizar múltiples flujos de datos de mercado simultáneamente, mientras la concurrencia maneja la ejecución de órdenes en un pool de hilos. Un ejemplo concreto:

  • Hilo 1: Recibe datos de precios de una API WebSocket, usando async/await para no bloquear.
  • Hilo 2: Procesa señales de trading con algoritmos en paralelo, usando rayon para data parallelism.
  • Hilo 3: Ejecuta órdenes a través de un canal seguro, con Mutex para asegurar que no haya condiciones de carrera en el libro de órdenes.

En pruebas de carga, este diseño redujo la latencia de 500 a 50 microsegundos, cumpliendo con requisitos de seguridad al validar cada transacción antes de ejecutarla.

Errores comunes

En sistemas avanzados, los errores en concurrencia y paralelismo pueden llevar a fallos catastróficos. Aquí tres errores típicos y cómo evitarlos:

  1. Deadlocks por uso incorrecto de Mutex: Ocurre cuando múltiples hilos se bloquean mutuamente esperando recursos. Solución: Usa timeouts con Mutex::try_lock o diseña jerarquías de bloqueo.
  2. Condiciones de carrera en datos compartidos: Sucede cuando hilos acceden a datos sin sincronización. Evítalo usando tipos como AtomicUsize para contadores o canales para comunicación sin estado compartido.
  3. Overhead excesivo por creación de hilos: Crear demasiados hilos puede degradar el rendimiento. Usa pools de hilos (rayon o tokio) para reutilizar recursos y ajustar al número de núcleos.

Checklist de dominio

Para verificar tu comprensión en este tema, asegúrate de poder:

  • Diferenciar claramente entre concurrencia y paralelismo en el contexto de sistemas de baja latencia.
  • Implementar canales (mpsc) para comunicación segura entre hilos sin condiciones de carrera.
  • Usar Arc<Mutex<T>> correctamente para compartir estado mutable, minimizando tiempos de bloqueo.
  • Medir y optimizar la latencia en código concurrente usando herramientas como criterion o perf.
  • Diseñar sistemas que escalen horizontalmente con pools de hilos, evitando cuellos de botella.
  • Aplicar principios de seguridad, como validación de datos antes de procesar en hilos paralelos.
  • Debuggar problemas de concurrencia usando RUST_BACKTRACE y análisis de memoria.

Implementa un sistema de procesamiento de logs seguro y de baja latencia

En este ejercicio, crearás un sistema que procese logs de seguridad de múltiples fuentes en tiempo real, aplicando concurrencia y paralelismo para minimizar la latencia mientras garantiza la integridad de los datos. Sigue estos pasos:

  1. Configura un proyecto Rust nuevo y añade las dependencias necesarias (e.g., rayon para paralelismo).
  2. Crea una estructura LogEntry que represente un log con campos como timestamp, nivel de severidad, y mensaje.
  3. Implementa un productor que simule la generación de logs desde tres fuentes diferentes (e.g., red, sistema, aplicación) usando hilos separados, enviando los logs a un canal compartido.
  4. Implementa un consumidor que reciba los logs del canal y los procese en paralelo usando rayon para aplicar filtros de seguridad (e.g., detectar patrones de ataque).
  5. Asegura que el sistema use Arc<Mutex<Vec<LogEntry>>> para almacenar logs procesados, con bloqueos mínimos para evitar deadlocks.
  6. Mide la latencia del procesamiento usando std::time::Instant y optimiza el número de hilos en el pool para balancear rendimiento y seguridad.
  7. Prueba el sistema con datos simulados, verificando que no haya pérdida de logs ni condiciones de carrera.
Pistas
  • Usa canales de tipo mpsc::channel::<LogEntry>() para comunicación entre hilos, evitando compartir estado innecesariamente.
  • Considera usar rayon::par_iter() para procesar logs en paralelo, pero asegúrate de que las operaciones sean thread-safe.
  • Para minimizar la latencia, limita el tamaño del pool de hilos al número de núcleos lógicos de tu sistema usando rayon::ThreadPoolBuilder.

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.