Lenguajes y Fundamentos de Programación · PY-106

Concurrencia: multihilo y multiproceso

Multihilo, multiproceso y asyncio para acelerar adquisición y E/S sin crear errores irreproducibles.

Disponible Avanzado 7 módulos · 33 clases

Formato asíncrono Desarrollo, Ingeniería / Industria Python

DESARROLLO

Lo que aprenderás

Distinguir carga limitada por E/S de carga limitada por CPU y elegir hilos, procesos o asyncio en consecuencia
Lanzar tareas concurrentes con ThreadPoolExecutor y ProcessPoolExecutor y recoger resultados y excepciones
Proteger estado compartido con Lock, RLock y estructuras de cola para evitar condiciones de carrera
Explicar el efecto del GIL en el rendimiento real de un programa multihilo
Escribir corrutinas con async y await para adquirir datos de muchas fuentes en paralelo
Diagnosticar interbloqueos y tareas colgadas con trazas, tiempos límite y registro por hilo
Cerrar de forma ordenada trabajadores y colas ante una señal de parada

Contenido del curso

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

Módulo 1 · Modelos de concurrencia 5 clases

Latencia y espera: dónde se va el tiempo de un programa
Carga de E/S frente a carga de CPU
Hilos, procesos y corrutinas comparados
El GIL explicado con mediciones
Entorno de trabajo y casos del curso

Módulo 2 · Hilos 5 clases

Crear y arrancar hilos con threading
ThreadPoolExecutor y recogida de resultados
Excepciones dentro de un hilo
Hilos demonio y finalización
Medir la mejora real en un caso de E/S

Módulo 3 · Estado compartido 5 clases

Condiciones de carrera con un contador compartido
Lock, RLock y secciones críticas
Colas como alternativa al bloqueo manual
Patrón productor-consumidor
Interbloqueos: cómo se producen y cómo se evitan

Módulo 4 · Multiproceso 5 clases

Procesos con multiprocessing y ProcessPoolExecutor
Serialización de argumentos y sus límites
Memoria compartida y coste de la comunicación
Paralelizar un cálculo intensivo por bloques
Cuándo el multiproceso no compensa

Módulo 5 · Programación asíncrona 5 clases

Corrutinas, async y await
El bucle de eventos y las tareas
Ejecutar muchas peticiones con gather
Tiempos límite y cancelación
Mezclar código bloqueante con asyncio

Módulo 6 · Observar y depurar 4 clases

Registro por hilo y por tarea
Detectar tareas colgadas y trabajadores muertos
Medición de tiempos y perfilado sencillo
Pruebas reproducibles de código concurrente

Módulo 7 · Caso práctico de cierre 4 clases

Adquisición concurrente desde múltiples fuentes
Cola de escritura única hacia almacenamiento
Parada ordenada ante señal del sistema
Comparación de rendimiento entre las tres estrategias

Requisitos

Dominio de Python: funciones, clases, excepciones y módulos
Experiencia previa escribiendo programas que leen ficheros o consultan servicios de red
Nociones básicas de procesos del sistema operativo y uso de la terminal

Descripción

Un programa que consulta cuarenta sensores uno detrás de otro pasa la mayor parte del tiempo esperando. La concurrencia recorta ese tiempo, pero introduce una clase de fallo nueva: el que aparece una vez de cada mil ejecuciones y no se reproduce cuando lo buscas. En adquisición de datos y en integración industrial ese fallo intermitente es exactamente lo que no se puede permitir.

El curso separa desde el principio los tres modelos de Python: hilos para espera de E/S, procesos para cálculo y asyncio para muchas conexiones simultáneas. Se practican los pools de ejecución, las colas como forma de comunicación segura, los mecanismos de bloqueo y los tiempos límite. Cada patrón se prueba en un caso de adquisición concurrente y se instrumenta para poder observar qué hace cada trabajador.

Al terminar se pueden paralelizar procesos de captura, descarga o transformación con criterios de corrección, no por prueba y error. Es la preparación adecuada para ejecutar cuadernos y procesos en servidor, para integrar clientes de protocolos industriales y para diseñar servicios que atienden a varios orígenes a la vez.

¿Para quién es este curso?

Desarrolladores que mantienen procesos de captura o integración que tardan más de lo aceptable
Ingenieros de sistemas industriales que leen de varios equipos o protocolos a la vez
Perfiles técnicos que preparan servicios de backend con muchas llamadas externas simultáneas