1. Resumen por bloques
| Bloque | Temas | Lo que aprendiste |
|---|---|---|
| 1. El problema de la concurrencia | 1-5 | Concurrencia vs. paralelismo, hilos que comparten datos, condiciones de carrera, counter++, simulador de intercalados. |
| 2. La sección crítica | 6-10 | Sección crítica, exclusión mutua, requisitos, primeros intentos fallidos, Peterson, simulador de exclusión mutua. |
| 3. Operaciones atómicas | 11-14 | stdatomic.h, test-and-set, compare-and-swap, spinlocks, orden de memoria y visibilidad. |
| 4. Mutex | 15-19 | Mutex en pthreads, granularidad, errores comunes, seguridad y reentrancia, detectar carreras. |
| 5. Semáforos | 20-24 | Semáforos (wait/post), POSIX, señalización, barreras, simulador de semáforos. |
| 6. Variables de condición y monitores | 25-28 | Variables de condición, despertares espurios, monitores, implementar monitor en C. |
| 7. Problemas clásicos | 29-34 | Productor-consumidor (semáforos y condición), lectores-escritores, pthread_rwlock, filósofos, simulador de problemas clásicos. |
| 8. Interbloqueos | 35-41 | Deadlock, grafos de asignación, prevención, evasión (banquero), detección, livelock/inanición/inversión, simulador de banquero. |
| 9. Más allá de los candados | 42-44 | Futex, estructuras lock-free, otros modelos (mensajes, canales, actores). |
| 10. Integración y cierre | 45-47 | Pool de hilos, transferencias bancarias, cierre. |
2. Qué dominas ahora
Al terminar este curso, dominas:
- Las condiciones de carrera: sabes qué son, por qué ocurren y cómo detectarlas.
- La sección crítica: sabes identificarla, protegerla y verificar que la solución es correcta.
- Las herramientas de sincronización: mutex, semáforos, variables de condición, monitores, operaciones atómicas.
- Los problemas clásicos: productor-consumidor, lectores-escritores, cena de los filósofos.
- Los interbloqueos: sabes prevenirlos, evitarlos y detectarlos.
- Las herramientas de análisis: ThreadSanitizer, Helgrind, strace, perf.
- Los modelos alternativos: paso de mensajes, actores, event loop.
3. Habilidades adquiridas
- Reconocer condiciones de carrera: en código C y en programas reales.
- Proteger secciones críticas: con mutex, semáforos y variables de condición.
- Coordinar hilos: con señalización, barreras y monitores.
- Diseñar sin interbloqueos: con orden de bloqueo y otras técnicas.
- Detectar errores: con ThreadSanitizer, Helgrind y herramientas de análisis.
- Observar hilos: con ps, top, /proc y strace.
4. Conceptos clave
Los conceptos fundamentales del curso son:
- Concurrencia: tener varias tareas en curso al mismo tiempo.
- Paralelismo: ejecutar varias tareas en el mismo instante en distintos núcleos.
- Condición de carrera: el resultado depende del intercalado de las instrucciones.
- Sección crítica: código que accede a un recurso compartido y no debe ejecutarse simultáneamente.
- Exclusión mutua: garantía de que solo un hilo ejecuta la sección crítica.
- Atomicidad: una operación que se ejecuta de forma indivisible.
- Mutex: candado que bloquea al hilo si está ocupado.
- Semáforo: contador de permisos con wait y post.
- Variable de condición: permite esperar a que se cumpla una condición sin gastar CPU.
- Monitor: abstracción que encapsula datos y sincronización.
- Interbloqueo: dos o más hilos que se esperan mutuamente para siempre.
- Inanición: un hilo espera indefinidamente por prioridad injusta.
- Livelock: hilos activos que no progresan.
- Inversión de prioridades: un hilo de alta prioridad bloqueado por un recurso de baja prioridad.
5. Próximos pasos
Después de este curso, puedes:
- Profundizar en sincronización: leer el código fuente de pthreads y del núcleo de Linux.
- Experimentar: modificar los simuladores, añadir nuevos algoritmos.
- Medir: usar ThreadSanitizer, Helgrind y otras herramientas para analizar programas reales.
- Contribuir: participar en el desarrollo de bibliotecas de sincronización.
- Estudiar más: el próximo curso es Gestión de Memoria.
6. Puente al próximo curso
El próximo curso es Gestión de Memoria. En este curso estudiaste cómo coordinar hilos que comparten datos. En el próximo, estudiarás cómo el sistema administra la memoria que todos ellos usan.
Los temas del próximo curso incluyen:
- Espacio de direcciones: cómo se organiza la memoria de un proceso.
- Paginación: cómo el sistema divide la memoria en páginas.
- Memoria virtual: cómo se simula más memoria de la disponible.
- Asignación de memoria: malloc, free y el heap.
- Garbage collection: cómo se gestiona la memoria automáticamente.
- Memoria compartida: cómo los procesos comparten memoria.
La concurrencia y la gestión de memoria son complementarias: los hilos comparten memoria, y el sistema gestiona esa memoria para que todos puedan usarla de forma eficiente.
En este curso viste cómo coordinar hilos que comparten datos. En el próximo, verás cómo el sistema gestiona la memoria que esos hilos comparten. La memoria es el recurso que todos los hilos usan, y su gestión es fundamental para el rendimiento y la corrección.
7. Resumen
- El curso cubre 47 temas en 10 bloques.
- Dominas las condiciones de carrera, la sección crítica, las herramientas de sincronización y los interbloqueos.
- Tienes las habilidades para reconocer, corregir y prevenir errores de concurrencia.
- El próximo curso es Gestión de Memoria.
8. Preguntas de repaso
Intenta responder cada una antes de abrir la respuesta.
1. ¿Cuántos temas tiene el curso?
47 temas en 10 bloques.
2. ¿Qué es una condición de carrera?
Un error que ocurre cuando el resultado depende del intercalado de hilos que acceden a un dato compartido.
3. ¿Qué es la exclusión mutua?
La garantía de que solo un hilo ejecuta la sección crítica a la vez.
4. ¿Qué son los tres requisitos de una solución correcta?
Exclusión mutua, progreso y espera acotada.
5. ¿Qué es un mutex?
Un candado que bloquea al hilo si está ocupado.
6. ¿Qué es un semáforo?
Un contador de permisos con wait y post.
7. ¿Qué es un interbloqueo?
Dos o más hilos que se esperan mutuamente para siempre.
8. ¿Qué es la herencia de prioridad?
El hilo que tiene el recurso hereda la prioridad del hilo bloqueado.
9. ¿Qué es un futex?
Fast userspace mutex: una primitiva que hace el trabajo en espacio de usuario.
10. ¿Cuál es el próximo curso?
Gestión de Memoria.