1. Por qué los programas necesitan cooperar
Imagina un programa que recibe imágenes, las comprime y guarda los resultados. Podrías escribir una única función que haga todo en orden. También podrías separar el trabajo: un proceso recibe solicitudes, varios comprimen y otro registra los resultados. Así puedes aprovechar varios núcleos, reemplazar un trabajador sin detener todo el servicio y limitar los permisos de cada parte.
La separación trae una pregunta nueva: ¿cómo entrega el receptor una imagen a un trabajador y cómo sabe que el resultado está listo? La respuesta requiere algún mecanismo de comunicación. No alcanza con ejecutar varios programas a la vez: necesitan una forma acordada de intercambiar datos o avisarse de un evento.
- División del trabajo. Un proceso produce tareas y otros las consumen.
- Composición. Herramientas pequeñas conectan su entrada y salida para resolver un problema mayor.
- Aislamiento. Un componente con pocos permisos puede pedir a otro una operación concreta.
- Compartición. Varios procesos consultan una misma caché o una región con resultados.
- Supervisión. Un proceso solicita una parada, detecta un hijo terminado o reinicia un trabajador.
No todos estos intercambios contienen lo mismo: «debes terminar» es un evento; una imagen son millones de bytes; «calcula el pedido 27» es un mensaje con estructura. Esa diferencia explica por qué el sistema operativo ofrece varios mecanismos de comunicación entre procesos.
2. Experimento: una variable no es un canal
Los hilos de un mismo proceso comparten su espacio de direcciones. Dos procesos tienen, en general, espacios de direcciones separados. Al llamar a fork, el hijo empieza con una copia del contenido del padre, pero las escrituras posteriores sobre variables ordinarias pertenecen a cada proceso. En Linux se utiliza habitualmente copy-on-write: no hace falta copiar físicamente toda la memoria en el instante de crear el hijo.
Guarda este programa como aislamiento.c. El hijo cambia una variable; el padre espera a que termine y luego consulta la suya. Los ejemplos se ejecutan en Linux o en una distribución Linux dentro de WSL.
#define _POSIX_C_SOURCE 200809L
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <unistd.h>
int main(void)
{
int valor = 10;
pid_t pid = fork();
if (pid == -1) {
perror("fork");
return EXIT_FAILURE;
}
if (pid == 0) {
valor = 99;
printf("Hijo: valor = %d\n", valor);
/* Vaciar stdout incluso si se redirige a un archivo. */
if (fflush(stdout) == EOF)
_exit(EXIT_FAILURE);
_exit(EXIT_SUCCESS);
}
int estado;
while (waitpid(pid, &estado, 0) == -1) {
if (errno == EINTR)
continue;
perror("waitpid");
return EXIT_FAILURE;
}
if (!WIFEXITED(estado) || WEXITSTATUS(estado) != EXIT_SUCCESS) {
fprintf(stderr, "El hijo no termino correctamente\n");
return EXIT_FAILURE;
}
printf("Padre: valor = %d\n", valor);
return EXIT_SUCCESS;
}
$ gcc -std=c17 -Wall -Wextra -Wpedantic aislamiento.c -o aislamiento
$ ./aislamiento
Hijo: valor = 99
Padre: valor = 10
El resultado no depende de que el padre haya sido «más rápido». waitpid garantiza que espera la terminación del hijo antes de imprimir. Aun así, su variable vale 10. Esperar establece un orden, pero no copia los cambios de memoria de un proceso al otro.
fork devuelve 0 al hijo y el PID del hijo al padre; devuelve −1 si falla. Ambos continúan desde la misma llamada, por caminos distintos. El hijo vacía explícitamente stdout y termina con _exit. El padre comprueba la terminación con WIFEXITED y WEXITSTATUS. El bucle reintenta si una señal interrumpe la espera y aparece EINTR.
Declarar valor como volatile no convierte su memoria en compartida. Añadir sleep(1) tampoco transmite el cambio ni constituye un protocolo fiable. Para compartir información hace falta un canal o una región creada expresamente para compartir.
Si imprimes (void *)&valor con %p en ambas ramas, podrías ver la misma dirección virtual. Eso tampoco prueba que la variable se comparta: cada dirección se interpreta dentro del espacio del proceso. La separación de memoria y los recursos heredados se documentan en fork(2), en el manual de Linux.
3. Qué significa IPC
IPC significa Interprocess Communication: el conjunto de mecanismos que permite a procesos intercambiar información y coordinar su actividad mediante canales, notificaciones o regiones de memoria compartida.
El sistema operativo proporciona objetos y operaciones: crear un canal, obtener una referencia a él, enviar, recibir, esperar y liberar recursos. El programa construye encima el significado del intercambio. Una tubería transporta bytes; no sabe que representan una imagen, un pedido o una instrucción para detenerse.
Hay dos modelos útiles para empezar. En el paso de mensajes o datos, un proceso entrega información a una interfaz y otro la recibe: tuberías, colas y sockets son ejemplos, aunque no todos conservan fronteras de mensaje. En la memoria compartida, ambos acceden a una región común y necesitan reglas de sincronización para usarla correctamente. Una señal suele servir para avisar de un evento sin transportar un volumen grande de datos.
La comunicación no exige parentesco entre los procesos. Un padre puede crear una tubería antes de fork para que la herede el hijo. Dos programas iniciados en terminales distintas pueden encontrarse por una FIFO, una cola con nombre o una dirección de socket Unix, siempre que los permisos lo permitan.
4. IPC que ya usas en la terminal
Este pipeline ejecuta programas y conecta la salida de uno con la entrada del siguiente:
$ printf 'rojo\nazul\nrojo\n' | sort
azul
rojo
rojo
$ printf 'rojo\nazul\nrojo\n' | sort | uniq -c
1 azul
2 rojoLa cantidad de espacios antes del contador puede variar. Lo importante es que sort recibe tres líneas y uniq agrupa las que llegan consecutivas. La shell prepara tuberías, crea procesos y conecta descriptores con operaciones como dup2. En muchas shells, printf es un comando interno; su ejecución en un pipeline depende de la shell, pero sus bytes llegan a los otros comandos por los canales preparados para ese pipeline.
| conecta la salida estándar del productor con la entrada estándar del consumidor. No significa «termina el primer programa y después arranca el siguiente». Los componentes pueden avanzar concurrentemente: uno escribe mientras otro lee, y el canal amortigua temporalmente sus diferencias de velocidad.
También podrías escribir en un archivo temporal y abrirlo desde otro programa. Eso permite intercambiar información, pero exige resolver cuándo está completo, quién lo borra y qué ocurre si ambos lo modifican. Una tubería ofrece un flujo con reglas de espera y fin de entrada adecuadas para componer estas herramientas.
5. El mapa de los mecanismos
La tabla presenta las herramientas del curso. Sirve para reconocer qué problema resuelve cada una; los criterios de elección se desarrollan en el tema 2.
| Mecanismo | Qué permite | Una precaución |
|---|---|---|
| Señales | Notificar eventos, como una solicitud de terminación. | Los manejadores tienen restricciones y las señales estándar pendientes pueden agruparse. |
| Tuberías anónimas | Enviar un flujo unidireccional mediante descriptores. | Hay que cerrar extremos sobrantes y delimitar los datos de la aplicación. |
| FIFO | Abrir un flujo mediante una ruta conocida. | La ruta tiene permisos y vida útil; no guarda un historial como un archivo regular. |
| Colas POSIX | Enviar unidades de mensaje con prioridades. | Tienen límites de cantidad y tamaño y requieren gestionar su nombre. |
| Memoria compartida | Acceder a una región común sin reenviarla completa en cada consulta. | Necesita sincronización y estructuras aptas para varios procesos. |
| Semáforos POSIX | Contar recursos y coordinar acceso y espera. | No transportan por sí solos el contenido de una tarea. |
| Sockets Unix | Conectar programas locales por flujos o mensajes, según el tipo. | Hay que definir direcciones, permisos y protocolo. |
| select, poll y epoll | Esperar disponibilidad en varios descriptores. | Multiplexan canales existentes: no crean un transporte nuevo. |
El alcance también importa: los sockets Unix conectan procesos dentro del mismo sistema; para comunicar equipos distintos se utilizan otros dominios y transportes, como TCP o UDP. Que dos programas se llamen microservicios no obliga a que estén en máquinas diferentes ni convierte una conexión local en una conexión de red.
6. Primer intercambio en C con pipe
Ahora el hijo enviará un texto al padre. pipe(canal) crea un canal y entrega dos descriptores: canal[0] para leer y canal[1] para escribir. Se crea antes de fork para que padre e hijo hereden referencias al mismo objeto del núcleo.
Guarda este programa como primer_ipc.c. El búfer de lectura tiene solo 8 bytes a propósito: el padre tendrá que repetir la lectura para reconstruir un texto más largo. Cada fragmento se muestra escribiendo exactamente los bytes recibidos, sin tratar el búfer como una cadena terminada en cero.
#define _POSIX_C_SOURCE 200809L
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <unistd.h>
/* Escribir todos los bytes aunque write complete solo una parte. */
static int escribir_todo(int fd, const char *datos, size_t cantidad)
{
size_t enviados = 0;
while (enviados < cantidad) {
ssize_t n = write(fd, datos + enviados, cantidad - enviados);
if (n == -1) {
if (errno == EINTR)
continue;
return -1;
}
if (n == 0) { /* Evitar un bucle sin avance. */
errno = EIO;
return -1;
}
enviados += (size_t)n;
}
return 0;
}
int main(void)
{
int canal[2];
if (pipe(canal) == -1) {
perror("pipe");
return EXIT_FAILURE;
}
pid_t pid = fork();
if (pid == -1) {
perror("fork");
close(canal[0]);
close(canal[1]);
return EXIT_FAILURE;
}
if (pid == 0) {
close(canal[0]); /* El hijo solo escribe. */
const char mensaje[] = "Hola desde el hijo\n";
int resultado = escribir_todo(canal[1], mensaje, sizeof mensaje - 1);
if (resultado == -1)
perror("write a la tuberia");
close(canal[1]); /* El padre podra ver EOF al agotar los bytes. */
_exit(resultado == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
}
close(canal[1]); /* El padre no debe conservar un escritor. */
char buffer[8];
int correcto = 1;
for (;;) {
ssize_t n = read(canal[0], buffer, sizeof buffer);
if (n > 0) {
if (escribir_todo(STDOUT_FILENO, buffer, (size_t)n) == -1) {
perror("write a stdout");
correcto = 0;
break;
}
} else if (n == 0) {
break; /* Canal vacio y ningun escritor abierto: EOF. */
} else if (errno != EINTR) {
perror("read");
correcto = 0;
break;
}
}
close(canal[0]);
int estado;
while (waitpid(pid, &estado, 0) == -1) {
if (errno == EINTR)
continue;
perror("waitpid");
return EXIT_FAILURE;
}
if (!WIFEXITED(estado) || WEXITSTATUS(estado) != EXIT_SUCCESS)
correcto = 0;
return correcto ? EXIT_SUCCESS : EXIT_FAILURE;
}$ gcc -std=c17 -Wall -Wextra -Wpedantic primer_ipc.c -o primer_ipc
$ ./primer_ipc
Hola desde el hijo
$ echo $?
0El ejemplo usa funciones POSIX disponibles en Linux; no es un programa Windows nativo. No necesita permisos de administrador. La preparación del entorno se detalla en el tema 3; basta contar aquí con un compilador C y una terminal de Linux.
7. Seguir el recorrido de los bytes
- Crear el canal. pipe devuelve referencias a un lector y un escritor. Los números concretos de descriptor dependen de qué tenía abierto el proceso.
- Crear el hijo. Tras fork, cada proceso tiene su tabla de descriptores, con referencias a los mismos extremos del canal.
- Descartar lo que no se usa. El hijo cierra su lector y el padre cierra su escritor. Queda un productor y un consumidor.
- Enviar el texto. El hijo escribe los 19 bytes del mensaje, incluido el salto de línea, pero sin el cero final del arreglo C:
sizeof mensaje - 1. - Consumir fragmentos. El padre procesa cada read positivo. Pide como máximo 8 bytes por vez, sin presuponer que la llamada entregue todo lo solicitado.
- Finalizar el flujo. El hijo cierra su escritor. Cuando el padre agota los bytes y no quedan escritores abiertos, read devuelve 0.
- Recoger al hijo. El padre cierra su lector, llama a waitpid y comprueba el estado de terminación.
Si el padre llega a read antes de que el hijo envíe datos, normalmente queda bloqueado: el núcleo lo pone en espera hasta que haya algo que leer o termine el flujo. No necesita consultar una variable repetidamente ni consumir CPU en un bucle vacío. Si el hijo escribe primero, los bytes quedan temporalmente en el canal.
escribir_todo acumula lo enviado y reintenta una interrupción con EINTR. El receptor distingue tres resultados: un número positivo significa bytes recibidos; cero significa fin de entrada; −1 significa error, con el detalle en errno. Son patrones que reutilizarás durante todo el curso.
Si el padre conserva su copia de canal[1], sigue existiendo un escritor abierto aunque el hijo termine. El padre puede leer todo el texto y luego quedarse esperando más datos en lugar de obtener EOF. El núcleo no sabe que ese descriptor conservado «no se va a usar».
La creación y los extremos se documentan en pipe(2); las reglas del flujo, capacidad y cierre, en pipe(7). El bloque 3 desarrollará estas reglas y su aplicación a pipelines.
8. Comunicación, sincronización y protocolo
Un sistema cooperativo necesita responder tres preguntas distintas, aunque una herramienta pueda ayudar con más de una.
¿Dónde están los datos?
La comunicación establece cómo llega información de A a B. Aquí pasa por una tubería. En memoria compartida, ambos acceden a una región común: no hace falta reenviar toda la región en cada consulta, aunque puede haber copias al preparar y procesar los datos.
¿Cuándo se pueden usar?
La sincronización establece orden y exclusión. Un consumidor puede esperar trabajo; un semáforo puede contar espacios libres o impedir que dos procesos modifiquen simultáneamente una estructura. Esperar a un hijo ordena actividades, pero no comparte sus variables.
La lectura bloqueante proporciona una espera por datos, pero no resuelve toda la coordinación. Si dos trabajadores actualizan una cuenta compartida, debes proteger la operación completa y definir qué sucede si uno falla.
¿Qué significan los bytes y dónde termina cada unidad?
El protocolo es el acuerdo entre los participantes: qué se envía, cómo se delimita y qué respuesta se espera. Nuestro protocolo es mínimo: el hijo envía un texto y cierra; el padre consume hasta EOF. Funciona para un único envío que termina con el canal.
Para mantener una conexión abierta con varias tareas hay que delimitar cada una. Podrías separar líneas con \n, preceder cada carga con su longitud o utilizar un mecanismo que conserve unidades de mensaje. Si el contenido puede incluir saltos de línea, separar por líneas exige un escape o una regla distinta.
| Concepto | En primer_ipc.c | No debe confundirse con |
|---|---|---|
| Transporte | La tubería mueve bytes del hijo al padre. | Interpretar los bytes como una tarea válida. |
| Espera | read puede dormir hasta que haya datos o EOF. | Compartir la memoria del hijo. |
| Delimitación | El cierre del último escritor marca el fin del envío. | Una lectura equivale a un mensaje completo. |
| Terminación | waitpid recoge y comprueba al hijo. | Confirmar que un dato se guardó de forma persistente. |
Escribir dos veces no obliga al receptor a leer dos veces: puede obtener parte del primer envío o bytes de varios envíos juntos. En memoria compartida hay otra dificultad: ver que cambió un campo no garantiza por sí solo que toda una estructura esté lista y publicada con la sincronización necesaria.
9. Explorar datos, cierre y EOF
Este explorador representa un canal con un único escritor. Pulsa Enviar para añadir tres bytes, Leer para consumir hasta dos y Cerrar escritor para indicar que no habrá más envíos. Sigue leyendo hasta llegar al fin del flujo.
Un flujo no es una secuencia de paquetes
Bytes pendientesVacío
Extremo escritorAbierto
Bytes recibidosNinguno
Última lecturaSin lecturas
Prueba a leer antes de enviar: un canal vacío con escritor abierto todavía no está en EOF.
Haz tres pruebas: lee antes de enviar; envía dos veces y observa que una lectura puede mezclar envíos; cierra con bytes pendientes y comprueba que todavía se consumen antes de recibir cero. Se usa un alfabeto ASCII para que cada carácter represente un byte.
Es un modelo didáctico, no una tubería del navegador: no reproduce su capacidad, señales ni planificación. Una lectura que debería bloquearse se representa mediante un aviso y debes pulsar otra vez para reintentar; en Linux la llamada queda esperando y puede reanudarse al llegar datos.
10. Aplicaciones en sistemas reales
Shell: composición por flujos
El pipeline de la sección 4 conecta programas que no necesitan conocerse. Uno produce texto en su salida y otro lo consume desde su entrada. La shell administra la topología, los cierres y los procesos. El proyecto del tema 15 construirá una versión pequeña de este patrón.
Servidor web: aceptar y repartir
Una arquitectura posible tiene un supervisor y varios trabajadores. El supervisor puede avisarles que terminen, distribuir trabajo por canales o entregarles descriptores de conexiones. Los sockets Unix permiten pasar descriptores mediante interfaces específicas. Otras arquitecturas usan hilos o un bucle de eventos; no todos los servidores web comparten el mismo diseño.
Base de datos: compartir y proteger
Una base de datos organizada en varios procesos puede mantener páginas o resultados en memoria compartida. Hace falta coordinar quién puede modificarlos y cuándo una versión está lista. Un semáforo ayuda a establecer turnos, pero no implementa por sí solo transacciones, recuperación ni escritura durable: comunicar un cambio no significa que sobreviva a un corte de energía.
Microservicios: peticiones con contrato
Dos servicios locales pueden comunicarse por un socket Unix para solicitar una transformación o consultar un resultado. Si se despliegan en equipos distintos, el transporte cambia y aparecen fallos de red. En ambos casos conviene definir identificadores de petición, respuestas, tiempos límite y qué ocurre al repetir una solicitud. El nombre de la arquitectura no sustituye ese contrato.
En estos ejemplos se repite una combinación: un medio para los datos, reglas de coordinación y una política de fallos. Aprender una llamada al sistema es el primer paso para construirla.
11. Qué puede salir mal
- Esperar un mensaje que nadie enviará. Un proceso puede morir antes de responder. El protocolo debe permitir detectar el cierre o terminar una espera con un límite.
- Conservar descriptores sobrantes. Una referencia heredada puede impedir EOF o mantener vivo un recurso.
- Acumular más de lo que se consume. Los canales tienen capacidad finita. Si el consumidor es lento, el productor debe esperar o aplicar una política explícita: es la contrapresión.
- Esperar al hijo demasiado pronto. Si el padre llama a waitpid antes de drenar el canal y el hijo lo llena, el hijo espera espacio mientras el padre espera su terminación.
- Dar por completo un mensaje parcial. read devuelve bytes, no necesariamente la unidad lógica que esperaba la aplicación.
- Compartir estructuras sin coordinación. Leer mientras otro escribe puede producir datos incoherentes, incluso en una región común.
- Confiar en un interlocutor sin validar. Un canal local también exige comprobar permisos, tamaños, formato e identidad del cliente.
El ejemplo lee antes de esperar para permitir que el hijo siga produciendo. No instala una política propia para SIGPIPE: si desaparece todo lector mientras se escribe en una tubería, la acción predeterminada puede terminar al escritor. En el recorrido normal el padre conserva su lector hasta consumir el texto. El tratamiento de señales y desconexiones se desarrollará en los bloques correspondientes.
La capacidad de una tubería no debe confundirse con PIPE_BUF, relacionado con garantías de atomicidad entre escritores. Tampoco hay que convertir una capacidad observada en una máquina en un supuesto del protocolo. El diseño debe permitir el progreso del consumidor y manejar el resultado de cada operación.
12. Cómo continúa el curso
El recorrido utiliza este intercambio como base. Primero dominarás los mecanismos por separado; después los combinarás en proyectos con varios participantes.
| Bloque | Temas | Pregunta central |
|---|---|---|
| 1. Fundamentos y entorno | 1–5 | ¿Qué queremos comunicar y qué herramientas necesitamos? |
| 2. Señales | 6–10 | ¿Cómo avisamos y esperamos eventos sin carreras? |
| 3. Tuberías anónimas y shells | 11–15 | ¿Cómo conectamos procesos y comandos? |
| 4. FIFO | 16–18 | ¿Cómo se encuentran programas independientes? |
| 5. Colas de mensajes | 19–22 | ¿Cómo enviamos tareas delimitadas y con prioridad? |
| 6. Memoria compartida | 23–26 | ¿Cómo acceden varios procesos a los mismos datos? |
| 7. Semáforos POSIX | 27–30 | ¿Cómo coordinamos acceso, recursos y espera? |
| 8. Sockets Unix | 31–35 | ¿Cómo construimos conversaciones locales? |
| 9. Multiplexación | 36–40 | ¿Cómo atendemos varios canales desde un bucle? |
| 10. Protocolos y diagnóstico | 41–44 | ¿Cómo delimitamos, detectamos fallos y medimos? |
| 11. Aplicaciones reales | 45–48 | ¿Cómo se combinan los patrones en sistemas mayores? |
| 12. Proyectos y cierre | 49–52 | ¿Cómo construimos y probamos servicios completos? |
Los fundamentos de C se retoman desde Programación en C para Sistemas Operativos; la creación y el aislamiento, desde Procesos e Hilos; la protección de estructuras, desde Concurrencia y Sincronización. Los descriptores y las operaciones de lectura y escritura se apoyan en Sistemas de Archivos y Entrada/Salida.
13. Resumen
- Los procesos cooperan para dividir trabajo, componer herramientas, compartir resultados y supervisarse.
- Una variable ordinaria modificada después de fork no comunica el cambio al otro proceso. waitpid ordena actividades, pero no comparte memoria.
- IPC reúne canales, notificaciones y memoria compartida, junto con mecanismos de coordinación.
- Una tubería conecta un escritor con un lector. Los descriptores heredados hacen referencia al mismo canal del núcleo.
- Un flujo de bytes no conserva fronteras de cada write: el receptor procesa los fragmentos recibidos.
- El receptor obtiene EOF cuando ya no hay datos pendientes ni extremos escritores abiertos.
- Comunicar datos, sincronizar accesos y definir un protocolo son responsabilidades relacionadas que conviene distinguir.
- select, poll y epoll permiten esperar varios descriptores; los canales siguen siendo otros objetos.
- Un diseño completo incluye capacidad finita, fallos, permisos y liberación de recursos.
14. Preguntas de repaso y práctica
Intenta explicar cada respuesta antes de desplegarla.
1. El padre espera al hijo y aun así valor sigue valiendo 10. ¿Por qué?
Porque las escrituras del hijo sobre su variable ordinaria no modifican la del padre. Esperar su terminación no convierte sus espacios de memoria en uno compartido.
2. ¿Ver la misma dirección virtual prueba que comparten la variable?
No. La dirección virtual se interpreta dentro de cada espacio de direcciones. Puede coincidir el número y existir contenido independiente.
3. ¿Por qué se crea la tubería antes de fork?
Para que el hijo herede referencias al canal creado por el padre. Crear después una tubería distinta en cada rama produciría canales separados.
4. ¿Qué pasa si el padre no cierra su escritor?
Tras consumir el texto puede quedar esperando: su propia referencia mantiene un escritor abierto y evita que la lectura detecte EOF.
5. El escritor cerró, pero quedan bytes. ¿Se pierden?
No. El lector puede consumirlos. Para una petición de tamaño mayor que cero, read devuelve cero cuando el canal está vacío y no quedan escritores.
6. ¿Cada write corresponde a un read?
No en un flujo: una lectura puede devolver un fragmento de un envío o combinar bytes de varios. El protocolo reconstruye las unidades lógicas.
7. ¿Por qué no mostramos cada lectura con printf("%s", buffer)?
Porque read entrega una cantidad de bytes y no añade un terminador nulo. El programa escribe exactamente la cantidad indicada por el valor de retorno.
8. ¿Un semáforo contiene los datos de una tarea?
No. Coordina recursos y espera. Los datos pueden residir en memoria compartida o viajar mediante otro mecanismo.
9. ¿Por qué esperar al hijo antes de leer puede causar un interbloqueo?
Si el hijo llena la tubería, espera que el padre consuma. Si el padre espera su terminación sin leer, ninguno puede completar la acción que desbloquea al otro.
10. ¿epoll transmite información entre procesos?
No crea un canal: notifica eventos de los descriptores registrados. Los datos se transfieren con las operaciones de los canales correspondientes.
11. ¿Los sockets Unix comunican directamente máquinas diferentes?
No. Operan dentro del mismo sistema. Para comunicar equipos se usan otros dominios y transportes, como sockets de Internet con TCP o UDP.
12. ¿Recibir una confirmación implica que un dato es durable?
Depende del contrato del servicio. La recepción o el envío de una respuesta no garantizan por sí solos que el dato se haya guardado de forma persistente.
Para practicar
- Compila aislamiento.c y cambia la variable a 200 antes de fork. Predice los valores del padre y del hijo y comprueba el resultado.
- Imprime la dirección de valor en las dos ramas. Explica por qué coincidir o cambiar entre ejecuciones no contradice el aislamiento.
- Reduce el búfer de lectura de primer_ipc.c a un byte y después a 64. El texto final debe ser idéntico. Explica qué cambia.
- Modifica el hijo para enviar dos textos consecutivos. Mantén el padre sin cambios y explica por qué la salida no permite deducir cuántas llamadas a write hizo el emisor.
- Quita temporalmente el cierre del escritor en el padre. Ejecuta con
timeout 3s ./primer_ipc: observa el texto y la espera posterior. Restaura el cierre. Si timeout termina el programa al vencer el plazo, suele devolver 124. - Construye un pipeline que ordene una lista de nombres y cuente los nombres únicos. Dibuja los procesos y canales antes de ejecutarlo.
- Diseña un protocolo de tareas: campos, delimitación, respuestas de éxito y error y comportamiento si desaparece el trabajador.
Debes poder explicar por qué hace falta IPC, seguir un envío por una tubería y distinguir datos, espera y protocolo. En el tema 2 compararás los mecanismos para elegir uno según el problema.