1. El recorrido del curso
En 43 temas recorriste el camino desde la idea de proceso hasta la decisión de usar procesos o hilos en un programa real. El curso se organizó en 10 bloques, cada uno respondiendo una pregunta:
| Bloque | Temas | La pregunta que respondió | Lo que aprendiste |
|---|---|---|---|
| 1. El concepto de proceso | 1-5 | ¿Qué es un proceso, qué tiene en su memoria y qué sabe el núcleo de él? | Programa vs proceso, imagen en memoria, PID, PCB, atributos. |
| 2. Estados y cambio de contexto | 6-10 | ¿Por qué estados pasa un proceso, y cómo se reparten la CPU? | Estados clásicos y en Linux, colas, planificador, cambio de contexto, modo usuario/núcleo, syscalls. |
| 3. Crear procesos con fork | 11-15 | ¿Cómo nace un proceso nuevo, y qué recibe de su padre? | fork, herencia, COW, varios hijos, cuando fork falla. |
| 4. Ejecutar programas con exec | 16-19 | ¿Cómo pasa un proceso a ejecutar otro programa? | Familia exec, fork+exec, argumentos y entorno, posix_spawn, vfork. |
| 5. Esperar y terminar | 20-23 | ¿Cómo termina un proceso, y cómo se entera su padre? | exit, _exit, atexit, wait, waitpid, señales. |
| 6. Zombis, huérfanos y demonios | 24-27 | ¿Qué pasa cuando padre e hijo no terminan en el orden esperado? | Zombis, evitar zombis, huérfanos, grupos, sesiones, demonios. |
| 7. Hilos y la biblioteca pthreads | 28-33 | ¿Cómo se divide un proceso en varios hilos que comparten la memoria? | Qué es un hilo, modelos, crear/esperar, pasar datos, terminar/cancelar, atributos. |
| 8. Hilos en profundidad | 34-36 | ¿Qué problemas trae compartir la memoria, y qué datos son de cada hilo? | Condiciones de carrera, mutex, datos propios, hilos+fork+exec+señales. |
| 9. Procesos frente a hilos en la práctica | 37-40 | ¿Cuándo conviene cada modelo en servidores, navegadores y videojuegos? | Comparar costos, servidores, navegadores, videojuegos. |
| 10. Integración y cierre | 41-43 | ¿Cómo se usa todo junto en una shell y en un programa paralelo? | Mini shell, procesar archivos en paralelo, cierre. |
Cada bloque construyó sobre el anterior. Los bloques 1 y 2 establecieron los conceptos fundamentales. Los bloques 3 y 4 enseñaron a crear y ejecutar procesos. El bloque 5 enseñó a terminar y esperar. El bloque 6 cubrió los casos especiales. Los bloques 7 y 8 introdujeron los hilos. El bloque 9 aplicó todo a casos reales. El bloque 10 integró todo en proyectos.
2. Las habilidades que dominas
Al terminar este curso, dominas las siguientes habilidades:
Crear y controlar
Sabes crear procesos con fork, ejecutar programas con exec, esperarlos con wait, y terminarlos con exit. Sabes evitar zombis y huérfanos.
Programar con pthreads
Sabes crear hilos con pthread_create, esperarlos con pthread_join, pasarles datos y recibir resultados. Sabes usar mutex y atributos.
Primer mutex
Sabes proteger datos compartidos con pthread_mutex. Entiendes las condiciones de carrera y cómo evitarlas.
Elegir el modelo
Sabes comparar procesos e hilos en costos, aislamiento y seguridad, y elegir el modelo adecuado para servidores, navegadores y videojuegos.
Además, dominas las herramientas de observación:
- ps, pstree, top: para ver procesos, hilos y su estado.
- /proc: para inspeccionar la memoria, los descriptores, los límites y el estado de cualquier proceso.
- strace: para ver las syscalls que hace un programa.
- gdb: para depurar programas con procesos e hilos.
Y dominas las buenas prácticas:
- Compilar con
-std=c17 -Wall -Wextra -pthread. - Pedir la interfaz POSIX con
#define _POSIX_C_SOURCE 200809L. - Comprobar cada llamada al sistema.
- Observar desde afuera con ps, pstree, /proc, strace.
- Usar
_exit()en el hijo después de fork. - Llamar a
fflush()antes de fork. - Comprobar el valor de retorno de fork.
- Esperar a los hijos con wait/waitpid.
- Recoger a los hijos con SIGCHLD + WNOHANG.
- Usar
_exit()en el hijo después de fork.
3. Lo que no se cubrió (y por qué)
Este curso cubre los fundamentos de procesos e hilos, pero hay temas avanzados que se dejaron para otros cursos:
| Tema | Por qué no se cubrió | Dónde se cubre |
|---|---|---|
| Algoritmos de planificación | Es un tema extenso que merece un curso propio. | Curso 6: Planificación de la CPU. |
| Sincronización avanzada | Mutex es solo el principio. Semáforos, variables de condición, barreras, etc. requieren un curso propio. | Curso 7: Concurrencia y Sincronización. |
| Comunicación entre procesos (IPC) | Tuberías, colas de mensajes, memoria compartida, sockets. Es un tema extenso. | Curso 10: Comunicación entre Procesos. |
| Gestión de memoria | Memoria virtual, paginación, segmentación, swap. Es un tema extenso. | Curso 8: Gestión de Memoria. |
| Sistemas de archivos | Organización de archivos, directorios, permisos, journaling. | Curso 9: Sistemas de Archivos y E/S. |
| Seguridad | Capacidades, namespaces, contenedores, SELinux. | Curso 12: Seguridad en Sistemas Operativos. |
Estos temas se cubren en los cursos siguientes de la ruta. Este curso se enfocó en los fundamentos: crear, ejecutar, esperar y controlar procesos e hilos. Los temas avanzados se construyen sobre esta base.
4. El puente al próximo curso
El próximo curso es Planificación de la CPU (curso 6 de la ruta). En este curso estudiaste cómo se crean, ejecutan y controlan los procesos. El próximo curso estudia cómo decide el sistema qué proceso se ejecuta en cada momento.
En este curso viste que:
- Los procesos pasan por estados (listo, en ejecución, bloqueado).
- El planificador elige qué proceso de la cola de listos se ejecuta.
- El cuanto de tiempo limita cuánto puede usar la CPU un proceso.
- Las prioridades (nice) afectan la planificación.
En el próximo curso profundizarás en:
| Tema | Qué estudiarás |
|---|---|
| Algoritmos de planificación | FCFS, SJF, Round Robin, Priority, Multilevel Queue, Multilevel Feedback Queue. |
| Criterios de evaluación | Tiempo de respuesta, tiempo de espera, tiempo de turnaround, throughput. |
| Planificación en Linux | CFS (Completely Fair Scheduler), tiempo real (SCHED_FIFO, SCHED_RR), nice, cgroups. |
| Multiprocesador | Planificación en sistemas con múltiples núcleos, afinidad de CPU, balanceo de carga. |
| Planificación de hilos | Cómo se planifican los hilos, contención, prioridades. |
| Casos reales | Cómo planifican Apache, Nginx, bases de datos, sistemas de tiempo real. |
El próximo curso te dará las herramientas para entender por qué un sistema se siente lento, cómo optimizar la respuesta, y cómo configurar la planificación para casos específicos.
En este curso creaste procesos e hilos. En el próximo, aprenderás cómo el sistema decide cuál de ellos usa la CPU en cada momento. Sin entender la planificación, no puedes entender el rendimiento del sistema.
5. Qué sigue en la ruta de aprendizaje
Este curso es el paso 5 de 15 en la ruta de Sistemas Operativos. Después de Planificación de la CPU (curso 6), los siguientes cursos son:
| Curso | Temas principales | Por qué importa |
|---|---|---|
| 6. Planificación de la CPU | Algoritmos, criterios, CFS, multiprocesador | Entender cómo se reparte la CPU |
| 7. Concurrencia y Sincronización | Mutex, semáforos, condiciones, deadlocks | Profundizar en sincronización |
| 8. Gestión de Memoria | Memoria virtual, paginación, swap, allocators | Entender la memoria de los procesos |
| 9. Sistemas de Archivos y E/S | Archivos, directorios, permisos, I/O | Entender cómo se almacenan los datos |
| 10. Comunicación entre Procesos | Pipes, colas, memoria compartida, sockets | Entender cómo se comunican los procesos |
Después de estos, los cursos avanzados cubren redes, seguridad, virtualización, rendimiento, depuración y construcción de un sistema operativo desde cero.
6. Recursos para seguir aprendiendo
Para profundizar en los temas de este curso:
- Libros:
- Operating System Concepts (Silberschatz, Galvin, Gagne) - el libro clásico.
- Advanced Programming in the UNIX Environment (Stevens, Rago) - la referencia para programación en Unix.
- The Linux Programming Interface (Michael Kerrisk) - la referencia más completa para Linux.
- Linux Kernel Development (Robert Love) - para entender el núcleo de Linux.
- Herramientas:
man 2 fork,man 2 execve,man 3 pthread_create- la documentación del sistema.strace,ltrace,perf- para observar y medir.gdb- para depurar./proc- para inspeccionar procesos.- Código fuente:
- El código fuente del núcleo de Linux:
kernel/fork.c,kernel/sched/,fs/exec.c. - glibc: la biblioteca de C que envuelve las syscalls.
- NPTL: la biblioteca de hilos de Linux.
La mejor forma de entender cómo funciona un sistema operativo es leer su código fuente. El núcleo de Linux es código abierto y está disponible en kernel.org. Empezar por kernel/fork.c es un buen punto de partida.
7. Resumen
- En 43 temas recorriste el camino desde "qué es un proceso" hasta "cómo elegir entre procesos e hilos".
- Dominas la creación, ejecución, espera y terminación de procesos (fork, exec, wait, exit).
- Dominas la programación de hilos (pthread_create, pthread_join, mutex, atributos).
- Entiendes las condiciones de carrera y cómo evitarlas con mutex.
- Sabes comparar procesos e hilos en costos, aislamiento y seguridad.
- Sabes cómo se aplican estos conceptos en servidores, navegadores y videojuegos.
- Completaste dos proyectos: una mini shell y un procesador de archivos en paralelo.
- El próximo curso es Planificación de la CPU, que estudia cómo se reparte la CPU entre procesos.
8. Preguntas de repaso
Intenta responder cada una antes de abrir la respuesta.
1. Qué aprendiste en el bloque 1 (concepto de proceso)?
Qué es un proceso, su imagen en memoria, el PCB, los atributos, y cómo verlos en /proc.
2. Qué aprendiste en el bloque 2 (estados y cambio de contexto)?
Los estados de un proceso, las colas, el planificador, el cambio de contexto, modo usuario/núcleo y syscalls.
3. Qué aprendiste en el bloque 3 (fork)?
Cómo crear procesos con fork, qué hereda el hijo, copia en escritura, varios hijos, y cuándo fork falla.
4. Qué aprendiste en el bloque 4 (exec)?
La familia exec, el patrón fork+exec, argumentos y entorno, y las alternativas (posix_spawn, vfork).
5. Qué aprendiste en el bloque 5 (esperar y terminar)?
Terminar un proceso (exit, _exit, atexit), wait y waitpid, esperar sin bloquearse, y controlar procesos con señales.
6. Qué aprendiste en el bloque 6 (zombis, huérfanos, demonios)?
Procesos zombis, cómo evitarlos, procesos huérfanos, grupos, sesiones y demonios.
7. Qué aprendiste en el bloque 7 (hilos)?
Qué es un hilo, modelos de hilos, crear y esperar hilos, pasar datos, terminar/separar/cancelar, atributos.
8. Qué aprendiste en el bloque 8 (hilos en profundidad)?
Memoria compartida y condiciones de carrera, mutex, datos propios del hilo, hilos+fork+exec+señales.
9. Qué aprendiste en el bloque 9 (práctica)?
Comparar costos y aislamiento, servidores, navegadores, videojuegos.
10. Qué aprendiste en el bloque 10 (integración)?
Mini shell, procesar archivos en paralelo, y este cierre.
Para practicar
- Revisa los temas que más te costaron y vuelve a leerlos.
- Implementa las extensiones de la mini shell (tuberías, redirección, variables).
- Extiende el procesador de archivos para soportar más formatos.
- Lee el código fuente de un servidor real (Nginx, Apache) y identifica los patrones que aprendiste.
- Lee el código fuente del núcleo de Linux (kernel/fork.c, kernel/sched/) para ver cómo se implementan los conceptos.
- Comienza el próximo curso: Planificación de la CPU.