Lenguajes y Fundamentos de Programación · LNG-304

Concurrencia y paralelismo comparados

Hilos, corrutinas, actores y canales comparados en Python, Go, Rust y Java sobre el mismo problema.

Próximamente Especialización 7 módulos · 35 clases

Formato asíncrono Desarrollo, Ingeniería / Industria Python, Go, Rust, Java

DESARROLLO

Lo que aprenderás

Distinguir concurrencia de paralelismo y elegir el modelo según si la carga es de CPU o de entrada y salida.
Explicar el efecto del GIL de Python y cuándo multiprocessing o asyncio son la salida correcta.
Escribir goroutines y canales en Go aplicando patrones de abanico de entrada y de salida.
Usar el sistema de propiedad y los tipos Send y Sync de Rust para evitar carreras en compilación.
Aplicar el marco de ejecutores y hilos virtuales de Java a cargas con muchas conexiones simultáneas.
Diagnosticar interbloqueos, inanición y carreras con herramientas de detección y trazas.
Medir la mejora real de una paralelización y contrastarla con la ley de Amdahl.

Contenido del curso

7 módulos · 35 clases en vídeo · práctica guiada en cada módulo

Módulo 1 · Fundamentos comunes 5 clases

Concurrencia y paralelismo: la distinción que decide todo
Procesos, hilos y cambio de contexto
Carga limitada por CPU frente a limitada por entrada y salida
Ley de Amdahl y expectativas realistas
Banco de pruebas comparativo del curso

Módulo 2 · Python 5 clases

El GIL: qué bloquea exactamente y qué no
threading para trabajo de entrada y salida
multiprocessing y el coste de serializar datos
asyncio: bucle de eventos, corrutinas y tareas
Errores típicos al mezclar código bloqueante con asyncio

Módulo 3 · Go 5 clases

Goroutines y el planificador del tiempo de ejecución
Canales con y sin búfer
select, tiempos de espera y cancelación con context
Patrones de abanico de entrada y de salida
Detector de carreras y depuración habitual

Módulo 4 · Rust 5 clases

Propiedad y préstamos aplicados a hilos
Arc y Mutex frente a canales mpsc
Los tipos Send y Sync explicados con ejemplos que no compilan
async y await con Tokio
Paralelismo de datos con Rayon

Módulo 5 · Java 5 clases

Hilos de plataforma y ejecutores
Colecciones concurrentes y CompletableFuture
Hilos virtuales: qué cambian y qué no
Concurrencia estructurada y propagación de errores
Modelo de memoria de Java y visibilidad

Módulo 6 · Problemas transversales 5 clases

Carreras de datos: cómo se manifiestan y cómo se detectan
Interbloqueo, livelock e inanición con casos reales
Cerrojos, secciones críticas y su coste
Estructuras sin cerrojos: promesa y realidad
Contrapresión cuando el productor supera al consumidor

Módulo 7 · Proyecto comparado de cierre 5 clases

Enunciado único: procesador de peticiones bajo carga
Implementación y medición en dos lenguajes elegidos
Perfilado y localización del cuello de botella
Tabla comparativa de latencia y consumo
Informe de decisión de arquitectura

Requisitos

Experiencia sólida en al menos dos de los cuatro lenguajes tratados.
Conocimiento de procesos, hilos y memoria a nivel de sistema operativo.
Haber depurado alguna vez un problema de rendimiento en producción.
Entorno local con los compiladores y tiempos de ejecución instalados, o el entorno preparado del curso.

Descripción

Cuando un servicio se satura, la respuesta habitual es lanzar más hilos y confiar en que el sistema operativo reparta. El resultado suele ser peor: contención sobre los mismos recursos, interbloqueos ocasionales y una carrera de datos que solo aparece bajo carga. Los cuatro lenguajes de este curso resuelven ese escenario con modelos distintos y decisiones de diseño deliberadas.

El planteamiento es comparativo. Un mismo problema, un procesador de peticiones con trabajo mixto de red y cálculo, se implementa en Python, Go, Rust y Java. Cada versión se instrumenta, se somete a carga y se analiza: dónde aparece la contención, qué garantiza el compilador, qué queda en manos del programador y cuánto cuesta cada abstracción en memoria y latencia.

Lo que se lleva quien lo cursa es criterio de arquitectura: saber cuándo un modelo de actores encaja mejor que un conjunto de hilos con cerrojos, y poder defenderlo con mediciones. Es base directa para trabajo en sistemas distribuidos, servicios de alta concurrencia y adquisición de datos industriales donde varias fuentes escriben a la vez.

¿Para quién es este curso?

Desarrolladores de servicios backend que afrontan picos de carga y latencias inestables.
Ingeniería de sistemas industriales que adquiere datos de varias fuentes simultáneas.
Perfiles técnicos que deben elegir lenguaje para un componente de alta concurrencia y justificarlo.