1. Un contador de permisos y dos operaciones
Un semáforo mantiene una cantidad no negativa de permisos. Una operación de espera intenta consumir uno; una operación de publicación añade uno. La decisión de consumir se realiza como parte de la operación del semáforo, sin que el programa tenga que consultar primero un contador y modificarlo por su cuenta.
sem_wait consume un permiso si puede hacerlo; si no hay ninguno, espera. sem_post publica un permiso y permite progresar a un participante que lo necesite.
Si el valor inicial es uno y los participantes respetan la regla de esperar antes de entrar y publicar una vez al salir, solo uno puede permanecer dentro de la sección crítica. Esa regla protegerá el contador del tema 26.
El semáforo no contiene el resultado de la tarea ni la estructura que se protege. Puedes combinarlo con memoria compartida, una cola u otro recurso, pero debes definir qué representa cada permiso.
2. Exclusión, capacidad y notificación
| Uso | Valor inicial típico | Significado del permiso |
|---|---|---|
| Exclusión mutua. | 1. | Derecho a ejecutar una sección crítica. |
| Capacidad limitada. | K. | Una plaza disponible de un conjunto de K recursos. |
| Notificación contable. | 0. | Un evento o unidad que un productor publicó. |
Con exclusión o capacidad, quien consume un permiso normalmente lo devuelve cuando deja de usar el recurso. Con notificación, el consumidor puede gastar una unidad sin devolverla: el próximo permiso corresponde a otro evento producido.
Publicar antes de que llegue un consumidor no pierde por sí mismo la unidad: el permiso queda disponible para una espera posterior, hasta los límites del semáforo. Esto no lo convierte en una cola de mensajes; el valor no identifica quién publicó ni transporta contenido.
Un semáforo inicializado a uno no impide que un programa ejecute dos sem_post y aumente su valor por encima de uno. «Binario» describe aquí la disciplina de uso, no una restricción automática de la API.
Tampoco hay propiedad de dueño como regla general del semáforo: otro proceso puede publicar. Esa flexibilidad sirve para notificaciones, pero obliga a vigilar el protocolo de exclusión. No debe suponerse que se detectará un post indebido solo porque lo hizo un proceso diferente.
No diseñes la corrección suponiendo turnos alternados ni un reparto equitativo bajo cualquier política de planificación. El contador protegido debe dar el total correcto aunque un trabajador consiga varios permisos consecutivos.
3. Las cinco interfaces del tema
sem_t *sem_open(const char *nombre, int flags, ...);
int sem_wait(sem_t *s);
int sem_post(sem_t *s);
int sem_close(sem_t *s);
int sem_unlink(const char *nombre);sem_open devuelve una referencia de tipo sem_t * o SEM_FAILED al fallar. No es un descriptor entero de archivo y no se comprueba con −1 ni suponiendo que su error sea necesariamente NULL.
Las otras cuatro funciones retornan cero al tener éxito y −1 al fallar, estableciendo errno. Cada retorno se interpreta según su operación: cerrar, esperar, publicar y retirar un nombre no son acciones intercambiables.
El valor sem_t * es una referencia local administrada por la biblioteca. Otro proceso obtiene su propia referencia abriendo el nombre, o la hereda mediante fork. No se envía ese puntero como un dato que un programa independiente deba desreferenciar.
Para un semáforo con nombre no se llama a sem_init ni a sem_destroy. Esas interfaces corresponden a los semáforos sin nombre, que estudiaremos en el tema 28.
4. Crear exclusivamente y abrir sin reinicializar
/* Crear un recurso nuevo para exclusion. */
sem_t *s = sem_open("/ipc27_demo", O_CREAT | O_EXCL, 0600, 1);
if (s == SEM_FAILED) {
perror("sem_open crear");
}
/* Abrir un recurso ya creado, sin modificar su valor. */
sem_t *existente = sem_open("/ipc27_demo", 0);Con O_CREAT se añaden dos argumentos: permisos y valor inicial. O_EXCL junto a O_CREAT exige una creación nueva. Si el nombre ya existe, el intento falla con EEXIST y no obtiene la propiedad del objeto.
Si se usa O_CREAT sin O_EXCL y el semáforo ya existe, los argumentos de permisos y valor inicial no lo reinicializan. Abrir con un valor uno no repara un semáforo existente que quedó en cero, según sem_open(3).
El participante abre con flags cero: no necesita O_RDWR, O_RDONLY ni O_NONBLOCK. No traslades los modos de apertura de shm_open o de una FIFO a esta interfaz. Las esperas sin bloqueo se abordarán mediante sem_trywait en el tema 29.
No soluciones una colisión borrando automáticamente el nombre y creándolo otra vez. Los procesos que ya lo abrieron podrían conservar una referencia al semáforo antiguo mientras los nuevos usan otro. Tendrías dos grupos creyendo proteger el mismo recurso con semáforos distintos.
5. Nombres, permisos y referencias locales
Usaremos una barra inicial y ningún separador adicional, por ejemplo /ipc27_sesionA. Las herramientas del tema aceptan solo el prefijo /ipc27_ seguido de letras ASCII, cifras, guion o guion bajo, con un máximo de 80 caracteres.
Ese límite es una política del laboratorio. El nombre se pasa a sem_open tal como se muestra, sin convertirlo en una ruta /dev/shm. En Linux puede observarse una representación llamada sem.ipc27_sesionA, pero la aplicación utiliza la API POSIX.
Los permisos 0600 solicitan acceso para el propietario, sujetos a umask. Los ejemplos entre terminales se ejecutan con el mismo usuario. Un nombre conocido no concede automáticamente permiso a otra cuenta.
Los procesos independientes abren el nombre por separado. Los hijos de fork heredan las referencias abiertas del padre. Tras un exec exitoso no debe suponerse que el nuevo programa conserva ese puntero utilizable: tendrá que establecer su conexión de acuerdo con su protocolo.
Los semáforos POSIX con nombre y los objetos de memoria compartida son recursos distintos. Reutilizar la misma cadena para ambos no enlaza automáticamente sus ciclos de vida ni inicializa los datos protegidos. La descripción de los recursos está en sem_overview(7).
6. Esperar y publicar correctamente
int r;
do {
r = sem_wait(s);
} while (r == -1 && errno == EINTR);
if (r == -1) {
perror("sem_wait");
/* No se adquirio el permiso: no entrar ni devolverlo. */
} else {
/* Seccion critica completa: leer, modificar y escribir. */
if (sem_post(s) == -1) {
perror("sem_post");
/* Fallo del protocolo; no continuar como si se hubiera liberado. */
}
}sem_wait puede bloquear si no hay permisos. Una interrupción con EINTR no equivale a una adquisición exitosa. En estos programas se reintenta porque no hay una política de cancelación basada en esa interrupción. La operación se documenta en sem_wait(3).
Un sem_post correcto incrementa el valor o permite que progrese un esperador. Puede fallar si excedería SEM_VALUE_MAX; no se debe ignorar ese retorno ni publicar reiteradamente como intento de recuperación, según sem_post(3).
La sección crítica debe contener todos los accesos que participan de la invariancia protegida. Para el contador incluye leer el valor anterior y escribir el nuevo. Una lectura anterior a sem_wait puede quedar obsoleta aunque la escritura posterior esté protegida.
El protocolo con sem_wait y sem_post también proporciona la coordinación de memoria necesaria para los accesos protegidos entre participantes. No hace falta declarar volatile el contador ni llamar a msync después de cada incremento.
7. Cerrar referencias y retirar el nombre
| Operación | Responsabilidad | Efecto |
|---|---|---|
| sem_close(s). | Cada proceso deja de utilizar su referencia. | No retira el nombre ni publica un permiso. |
| sem_unlink(nombre). | El responsable administra el nombre. | Impide nuevas aperturas por ese nombre mientras no se recree. |
| Último cierre de un semáforo sin nombre público. | No quedan usuarios de esa generación. | Puede destruirse el objeto. |
sem_close libera la referencia local; no se sustituye por close ni por free. Su contrato se describe en sem_close(3).
sem_unlink retira inmediatamente el nombre, pero las referencias existentes siguen siendo utilizables. El objeto termina de destruirse cuando se cierran las referencias restantes, según sem_unlink(3).
En un servicio con participantes independientes el nombre se conserva mientras deban conectarse otros procesos. En una familia creada con fork puede retirarse antes de crear los hijos si estos heredarán la referencia ya abierta. Veremos ambas políticas.
Ni cerrar ni retirar un nombre «devuelve» un permiso consumido. Una caída en la sección crítica puede dejar el valor en cero para otros usuarios. El ciclo de vida de las referencias y el equilibrio de permisos son dos responsabilidades diferentes.
8. Código de apoyo para los ejemplos
Guarda apoyo27.h junto a los programas. La cabecera valida nombres y cantidades, y encapsula el reintento de sem_wait ante EINTR.
#ifndef APOYO27_H
#define APOYO27_H
#define _DEFAULT_SOURCE
#include <errno.h>
#include <fcntl.h>
#include <inttypes.h>
#include <semaphore.h>
#include <signal.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <unistd.h>
static inline int numero(const char *s, unsigned minimo,
unsigned maximo, unsigned *salida)
{
if (!*s) return -1;
for (const char *p = s; *p; ++p)
if (*p < '0' || *p > '9') return -1;
errno = 0;
char *fin;
unsigned long x = strtoul(s, &fin, 10);
if (errno || *fin || x < minimo || x > maximo) return -1;
*salida = (unsigned)x;
return 0;
}
static inline int nombre_valido(const char *s)
{
size_t n = strlen(s);
if (n <= 7 || n > 80 || strncmp(s, "/ipc27_", 7) != 0) return 0;
for (size_t i = 7; i < n; ++i) {
unsigned char c = (unsigned char)s[i];
if (!((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') ||
(c >= '0' && c <= '9') || c == '_' || c == '-')) return 0;
}
return 1;
}
static inline int esperar_permiso(sem_t *s)
{
int r;
do { r = sem_wait(s); } while (r == -1 && errno == EINTR);
return r;
}
#endifLa macro _DEFAULT_SOURCE expone MAP_ANONYMOUS en glibc al compilar el segundo programa con C17 estricto. Los ejemplos se ejecutan en Linux o dentro de una distribución Linux de WSL.
9. Programa: administrar y usar un semáforo
Guarda sem27.c. Crear admite un valor inicial de cero a 32 como política de prueba. Esperar consume una unidad sin devolverla; publicar añade una; usar adquiere un permiso, espera Enter y lo devuelve. Retirar elimina solo el nombre.
La operación usar permite observar exclusión desde dos terminales. Si la entrada termina con EOF, también intenta devolver el permiso antes de informar el fallo. No recupera caídas por señales que terminen abruptamente el proceso.
#include "apoyo27.h"
int main(int argc, char **argv)
{
if (argc < 3 || !nombre_valido(argv[2])) goto uso;
int crear = strcmp(argv[1], "crear") == 0;
int esperar = strcmp(argv[1], "esperar") == 0;
int publicar = strcmp(argv[1], "publicar") == 0;
int usar = strcmp(argv[1], "usar") == 0;
int retirar = strcmp(argv[1], "retirar") == 0;
unsigned inicial = 0;
if (crear) {
if (argc != 4 || numero(argv[3], 0, 32, &inicial) == -1) goto uso;
} else if (argc != 3 || !(esperar || publicar || usar || retirar)) {
goto uso;
}
if (retirar) {
if (sem_unlink(argv[2]) == -1) {
perror("sem_unlink"); return EXIT_FAILURE;
}
puts("Nombre retirado");
return EXIT_SUCCESS;
}
sem_t *s = crear ? sem_open(argv[2], O_CREAT | O_EXCL, 0600, inicial)
: sem_open(argv[2], 0);
if (s == SEM_FAILED) {
perror("sem_open");
return EXIT_FAILURE; /* No retirar un nombre que no creamos. */
}
int salida = EXIT_SUCCESS;
int prestado = 0;
if (crear) {
printf("Creado con valor inicial %u\n", inicial);
} else if (esperar || usar) {
puts("Esperando un permiso...");
fflush(stdout);
if (esperar_permiso(s) == -1) {
perror("sem_wait"); salida = EXIT_FAILURE; goto fin;
}
if (usar) {
prestado = 1;
puts("Permiso adquirido. Pulsa Enter para devolverlo.");
fflush(stdout);
if (getchar() == EOF) {
fprintf(stderr, "EOF: se devolvera el permiso antes de salir\n");
salida = EXIT_FAILURE;
}
} else {
puts("Permiso consumido");
}
} else if (publicar) {
if (sem_post(s) == -1) {
perror("sem_post"); salida = EXIT_FAILURE;
} else {
puts("Permiso publicado");
}
}
fin:
if (prestado && sem_post(s) == -1) {
perror("sem_post al devolver"); salida = EXIT_FAILURE;
}
if (fflush(stdout) == EOF || ferror(stdout)) {
fprintf(stderr, "Error en la salida\n"); salida = EXIT_FAILURE;
}
if (sem_close(s) == -1) {
perror("sem_close"); salida = EXIT_FAILURE;
}
if (crear && salida != EXIT_SUCCESS && sem_unlink(argv[2]) == -1)
perror("sem_unlink tras fallo de creacion");
return salida;
uso:
fprintf(stderr, "Uso: %s crear /ipc27_nombre valor(0..32)\n"
" %s esperar|publicar|usar|retirar /ipc27_nombre\n",
argv[0], argv[0]);
return EXIT_FAILURE;
}La variable prestado solo se activa después de adquirir correctamente en usar. Así no se publica un permiso por una espera fallida. En esperar se consume intencionalmente una unidad; no se interpreta como un préstamo de exclusión.
La creación conserva el nombre después de sem_close para que otras invocaciones puedan abrirlo. La limpieza por fallo solo retira un nombre que esta invocación llegó a crear. El laboratorio presupone que nadie sustituye ese nombre durante su administración.
10. Laboratorio entre procesos independientes
$ gcc -std=c17 -O2 -Wall -Wextra -Wpedantic sem27.c -o sem27 -pthreadLa opción -pthread configura la compilación y el enlace adecuados para estas interfaces, aunque los ejemplos no creen hilos. No se usa -lrt como sustituto de la configuración de semáforos.
Un evento que comienza sin permisos
Elige un nombre propio y úsalo en ambas terminales. Si ya existe, cambia de nombre; no retires un recurso que no sabes quién está utilizando.
$ ./sem27 crear /ipc27_eventoA 0 && ./sem27 esperar /ipc27_eventoA
Creado con valor inicial 0
Esperando un permiso...$ ./sem27 publicar /ipc27_eventoA
Permiso publicadoA debe continuar e imprimir «Permiso consumido». El cierre de A no vuelve a publicar: el evento ya fue consumido. Si invocas esperar otra vez, necesitará una publicación nueva.
$ ./sem27 retirar /ipc27_eventoATambién puedes publicar antes de lanzar al consumidor: el permiso quedará disponible. No hace falta acertar un instante de llegada ni usar sleep para evitar perder el aviso.
Un permiso de exclusión que se devuelve
$ ./sem27 crear /ipc27_turnoA 1 && ./sem27 usar /ipc27_turnoA
Creado con valor inicial 1
Esperando un permiso...
Permiso adquirido. Pulsa Enter para devolverlo.$ ./sem27 usar /ipc27_turnoA
Esperando un permiso...Ahora pulsa Enter en A. B podrá adquirir el permiso y pedir su propio Enter. Después de devolverlo en B, retira el nombre con ./sem27 retirar /ipc27_turnoA.
La pausa con getchar permite observar quién conserva el permiso; no intenta estimar con una demora cuándo terminará otro proceso. En un programa real, el trabajo protegido reemplaza esa pausa.
No ejecutes publicar desde una tercera terminal para «ayudar» a B en esta prueba. Estarías agregando un permiso mientras A todavía ocupa la sección, con lo que ambos podrían entrar. Publicar es correcto en el laboratorio de eventos y un error de protocolo en esa situación de exclusión.
11. Programa: un contador protegido
Guarda contador27.c. Un supervisor crea una región anónima para el contador y un semáforo con nombre inicializado a uno. Retira el nombre antes de fork porque todos los participantes heredarán la referencia y no habrá clientes externos.
Cada hijo protege la lectura-modificación-escritura completa. El padre comprueba el resultado después de recogerlos. Si detecta un hijo fallido o falla la creación de otro, cancela a los pendientes y descarta el contador.
#include "apoyo27.h"
struct hijo { pid_t pid; int recogido; };
static int trabajar(sem_t *s, uint64_t *contador, unsigned iteraciones)
{
for (unsigned i = 0; i < iteraciones; ++i) {
if (esperar_permiso(s) == -1) return 2;
/* No leer el valor anterior fuera de la seccion critica. */
uint64_t anterior = *contador;
*contador = anterior + 1;
if (sem_post(s) == -1) return 3;
}
return 0;
}
int main(int argc, char **argv)
{
unsigned cantidad, iteraciones;
if (argc != 3 || numero(argv[1], 1, 8, &cantidad) == -1 ||
numero(argv[2], 1, 1000000, &iteraciones) == -1) {
fprintf(stderr, "Uso: %s trabajadores(1..8) iteraciones(1..1000000)\n",
argv[0]);
return EXIT_FAILURE;
}
uint64_t *contador = mmap(NULL, sizeof *contador, PROT_READ | PROT_WRITE,
MAP_SHARED | MAP_ANONYMOUS, -1, 0);
if (contador == MAP_FAILED) { perror("mmap"); return EXIT_FAILURE; }
*contador = 0;
sem_t *s = SEM_FAILED;
char nombre[96];
int nombrado = 0, fallo = 0;
struct hijo hijos[8];
unsigned creados = 0, recogidos = 0;
for (unsigned intento = 0; intento < 100; ++intento) {
int n = snprintf(nombre, sizeof nombre, "/ipc27_cont_%ld_%u",
(long)getpid(), intento);
if (n < 0 || (size_t)n >= sizeof nombre) {
fprintf(stderr, "Nombre demasiado largo\n"); fallo = 1; goto fin;
}
s = sem_open(nombre, O_CREAT | O_EXCL, 0600, 1);
if (s != SEM_FAILED) { nombrado = 1; break; }
if (errno != EEXIST) break;
}
if (s == SEM_FAILED) { perror("sem_open"); fallo = 1; goto fin; }
if (sem_unlink(nombre) == -1) {
perror("sem_unlink temprano"); fallo = 1; goto fin;
}
nombrado = 0;
for (unsigned i = 0; i < cantidad; ++i) {
pid_t pid = fork();
if (pid == -1) { perror("fork"); fallo = 1; goto fin; }
if (pid == 0) {
int codigo = trabajar(s, contador, iteraciones);
if (sem_close(s) == -1) codigo = 4;
if (munmap(contador, sizeof *contador) == -1) codigo = 5;
_exit(codigo);
}
hijos[creados++] = (struct hijo){pid, 0};
}
/* Esperar al que termine, para detectar un fallo sin esperar a otro PID. */
while (recogidos < creados) {
int estado;
pid_t pid;
do { pid = waitpid(-1, &estado, 0); } while (pid == -1 && errno == EINTR);
if (pid == -1) { perror("waitpid"); fallo = 1; goto fin; }
unsigned indice = 0;
while (indice < creados && hijos[indice].pid != pid) ++indice;
if (indice == creados || hijos[indice].recogido) {
fprintf(stderr, "PID inesperado al recoger\n"); fallo = 1; goto fin;
}
hijos[indice].recogido = 1;
++recogidos;
if (!WIFEXITED(estado) || WEXITSTATUS(estado) != 0) {
fprintf(stderr, "Fallo de trabajador; se descarta el contador\n");
fallo = 1; goto fin;
}
}
{
uint64_t esperado = (uint64_t)cantidad * iteraciones;
printf("Trabajadores recogidos: %u\nEsperado: %" PRIu64 "\n",
recogidos, esperado);
printf("Contador protegido: %" PRIu64 "\n", *contador);
if (*contador != esperado) fallo = 1;
}
fin:
/* Cancelar primero a todos los pendientes, luego recogerlos. */
if (fallo) {
for (unsigned i = 0; i < creados; ++i) {
if (!hijos[i].recogido && kill(hijos[i].pid, SIGKILL) == -1 &&
errno != ESRCH) perror("kill hijo pendiente");
}
}
for (unsigned i = 0; i < creados; ++i) {
if (hijos[i].recogido) continue;
int estado;
pid_t pid;
do { pid = waitpid(hijos[i].pid, &estado, 0); }
while (pid == -1 && errno == EINTR);
if (pid == -1) { perror("waitpid limpieza"); fallo = 1; }
else hijos[i].recogido = 1;
}
if (s != SEM_FAILED && sem_close(s) == -1) {
perror("sem_close padre"); fallo = 1;
}
if (nombrado && sem_unlink(nombre) == -1) {
perror("sem_unlink limpieza"); fallo = 1;
}
if (munmap(contador, sizeof *contador) == -1) { perror("munmap"); fallo = 1; }
return fallo ? EXIT_FAILURE : EXIT_SUCCESS;
}El contador es ordinario, sin volatile. Todos sus accesos concurrentes de modificación están dentro de la misma exclusión, y el padre solo lee cuando los trabajadores ya terminaron correctamente.
El semáforo fue creado con nombre y abierto mediante sem_open. Retirar pronto ese nombre no lo convierte en un semáforo sin nombre de sem_init; su interfaz de cierre sigue siendo sem_close.
El supervisor es un programa independiente, sin otros hijos ni recolectores compitiendo por waitpid. Esperar al que termine permite detectar un fallo aunque otro trabajador esté bloqueado por un permiso que no volverá.
Se conserva si cada PID ya fue recogido. La cancelación solo actúa sobre hijos pendientes, cuyos PID aún pertenecen a esta relación de supervisión. Primero se envía la cancelación a todos y después se realizan las esperas de limpieza.
12. Compilar y comprobar el contador
$ gcc -std=c17 -O2 -Wall -Wextra -Wpedantic contador27.c -o contador27 -pthread
$ ./contador27 2 100000
Trabajadores recogidos: 2
Esperado: 200000
Contador protegido: 200000
$ ./contador27 8 1000
Trabajadores recogidos: 8
Esperado: 8000
Contador protegido: 8000
$ ./contador27 1 1
Trabajadores recogidos: 1
Esperado: 1
Contador protegido: 1A diferencia del experimento sin_proteccion del tema 26, aquí sí hay una condición numérica exigible: cantidad × iteraciones. Un resultado diferente o una terminación fallida provoca retorno de error.
La espera del padre comprueba finalización y valida la ejecución; el semáforo protege los incrementos mientras trabajan los hijos. Ambas responsabilidades son necesarias y se cumplen en momentos distintos.
El total máximo es ocho millones, representable en uint64_t. No se imprime dentro de la sección crítica ni se introduce una demora para producir un reparto visible.
El programa realiza muchas adquisiciones cortas. La contención puede hacerlo más lento que acumular en casillas y reducir al final. El propósito es aprender la exclusión de un contador común, no demostrar que este diseño sea el más rápido para cualquier carga.
13. Por qué funciona la sección crítica
Para demostrar la exclusión no basta con afirmar que hay un semáforo. Hay que relacionar su valor inicial y el balance de operaciones con el código que protege.
- Existe un permiso inicial. Todos los hijos comparten la misma referencia heredada al objeto creado con valor uno.
- Solo se entra tras una adquisición exitosa. Una espera fallida termina el trabajo sin tocar el contador.
- El permiso se conserva durante todo el incremento. La lectura anterior y la escritura nueva quedan dentro de la sección.
- Se publica una vez por adquisición normal. No hay posts ajenos que aumenten la capacidad de entrada.
- El padre acepta solo una ejecución completa. Una caída hace descartar el conjunto y cancelar a los pendientes.
En una ejecución exitosa, cada incremento parte del valor dejado por la sección anterior. Por inducción, después de K incrementos completos el contador vale K. Cuando todos los hijos completaron sus iteraciones, K coincide con el total esperado.
La prueba no requiere que el trabajador 1 alterne con el 2 ni que ambos progresen a la misma velocidad. La exclusión conserva el dato con cualquier secuencia de adquisiciones que cumpla el protocolo.
Si se inicializara a dos, podrían coincidir dos operaciones sobre el contador y la demostración dejaría de valer. Si alguien ejecutara un post extra, también podría aumentar la cantidad de participantes dentro.
Un semáforo de exclusión tampoco es recursivo por convenio. Si un proceso que mantiene el único permiso vuelve a esperar antes de devolverlo, puede quedar esperando una publicación que él mismo impide realizar.
14. Fallos, permisos perdidos y recuperación
| Fallo | Interpretación | Respuesta del ejemplo |
|---|---|---|
| EEXIST al crear. | Otro objeto ya ocupa el nombre. | No adoptarlo ni retirarlo como propio. |
| ENOENT al abrir. | No hay un nombre disponible para conectar. | Informar el error; revisar la secuencia o el nombre. |
| EINTR en sem_wait. | La espera fue interrumpida. | Reintentar en estos programas, sin entrar antes del éxito. |
| Fallo de sem_post. | No se completó la publicación. | Informar y fallar; el contador no se considera aceptado. |
| Muerte de un hijo. | Puede haber datos incompletos y un permiso perdido. | Cancelar a los restantes y descartar la ejecución. |
| Hijo vivo pero detenido indefinidamente. | No hay todavía una terminación que recoger. | Queda fuera del presupuesto de supervisión de este ejemplo. |
Si un proceso muere después de sem_wait y antes de sem_post, el semáforo no devuelve automáticamente el permiso. El cierre de su referencia no inspecciona ni revierte la sección crítica que estaba ejecutando.
Publicar desde fuera para desbloquear a otros no demuestra que los datos estén consistentes. Tampoco sabes, solo por observar valor cero, si hay un propietario vivo, uno muerto o un evento que aún no se produjo.
El contador adopta una política concreta de fallo total. El supervisor detecta la terminación fallida, cancela hijos directos pendientes y no usa el dato parcial. No intenta continuar un servicio sobre el mismo estado.
No hay un plazo global para detectar suspensiones de un proceso que no termina. Las esperas con límite, la cancelación y los límites de recuperación se desarrollarán en el tema 29. La terminación del padre por SIGKILL tampoco ejecuta su limpieza ni su política de cancelación.
La retirada temprana del nombre evita un nombre residual después de esa fase. Si el supervisor cae en el intervalo entre sem_open y sem_unlink, todavía puede quedar el nombre creado. Un servicio real debe definir cómo reconocer y administrar recursos de ejecuciones fallidas.
15. Observar sin decidir por sem_getvalue
sem_getvalue puede servir para inspeccionar un semáforo, pero el valor observado puede cambiar antes de que tomes otra decisión. No implementes «si hay un permiso, entonces entro» consultando y actuando por separado.
/* Incorrecto como protocolo de entrada. */
sem_getvalue(s, &valor);
if (valor > 0) {
/* Otro proceso puede consumir el permiso antes de este punto. */
/* No se adquirio nada para proteger un acceso a los datos. */
}La operación de adquisición es sem_wait o, cuando corresponda, sem_trywait. Linux devuelve cero al consultar un semáforo con esperadores, sin usarlo como un contador negativo de procesos bloqueados. Los detalles y el carácter transitorio del resultado están en sem_getvalue(3).
Representación de Linux y llamadas de biblioteca
$ ./sem27 crear /ipc27_inspeccionA 1
$ ls -l /dev/shm/sem.ipc27_inspeccionA
$ strace -f -e trace=openat,mmap,munmap,close,futex,unlink,link ./sem27 usar /ipc27_inspeccionA
$ ./sem27 retirar /ipc27_inspeccionALa representación suele estar en /dev/shm y puede verse como un pequeño archivo. No se edita su contenido ni se usa free sobre el objeto de biblioteca. La API de aplicación sigue siendo sem_open y sus operaciones asociadas.
Una adquisición sin contención puede resolverse sin una llamada futex visible. Cuando hay espera, la biblioteca y el núcleo coordinan el bloqueo. No esperes una llamada al sistema llamada sem_wait por cada invocación de la función C.
Las llamadas concretas y los archivos temporales internos dependen de la implementación. Usa la traza para entender cuándo se conecta y bloquea, no para basar el contrato en detalles privados de glibc.
16. Explorar permisos y exclusión
El modelo comienza con un permiso y dos participantes fuera de la sección crítica. Pedir consume si hay disponibilidad; si no, representa una espera pendiente. Devolver publica una vez desde el participante que estaba dentro.
Permisos disponibles1
Participante AFuera
Participante BFuera
Invariancia de exclusión0 dentro; capacidad prevista: 1
Pide el permiso desde A y después desde B.
Para hacer visibles los pasos del planificador, una espera pendiente continúa al pulsar «Pedir / reanudar» cuando existe un permiso. En el sistema real la llamada bloqueada no necesita que el programa vuelva a llamarla: puede progresar tras una publicación.
El botón de publicación extra muestra un error deliberado de exclusión. Con A dentro y B esperando, publica una unidad y reanuda B: ambos estarán dentro. La API puede aceptar la publicación aunque el protocolo se haya roto.
El simulador no promete un orden FIFO de despertar ni reproduce las carreras internas de implementación. Distingue permisos disponibles, participantes dentro y esperas pendientes para explicar el balance que mantiene la aplicación.
17. Pruebas y errores frecuentes
Operaciones entre programas independientes
- Nombre ausente. Publicar o esperar sobre un nombre que no existe debe fallar, sin crearlo.
- Colisión. Crea un semáforo propio con cero y vuelve a crear con uno. El segundo intento debe fallar y no habilitar una espera por accidente.
- Permisos acumulados. Crea con cero, publica dos veces y consume dos veces. Una tercera espera necesitará una publicación nueva.
- Exclusión. Mantén A en usar y verifica que B no informa adquisición hasta que A devuelva el permiso.
- EOF de entrada. Ejecuta usar con entrada vacía. Debe intentar devolver el permiso adquirido y retornar error.
- Retirada. Cierra referencias y retira el nombre propio. Una apertura posterior debe fallar.
No compruebes un bloqueo esperando indefinidamente en una prueba automática. Un controlador de pruebas puede lanzar el consumidor, confirmar su mensaje de espera y publicar desde otro proceso para que termine. La espera de observación debe tener un límite y una limpieza definida.
Contador y supervisión
$ for prueba in 1 2 3 4 5; do ./contador27 4 10000 || exit 1; done
$ ./contador27 0 100
Uso: ./contador27 trabajadores(1..8) iteraciones(1..1000000)Prueba además uno y ocho trabajadores, límites numéricos y modos de uso inválidos. No exijas que aparezca un reparto alternado de adquisiciones: el programa valida el total y la recolección, no la equidad.
En una copia de prueba, simula el fallo de un fork intermedio y comprueba que se cancelan y recogen los ya creados. En otra variante, termina un hijo inmediatamente después de adquirir el permiso; el padre debe detectar el fallo, cancelar al resto y salir con error sin mostrar el contador como válido.
| Síntoma | Causa que conviene revisar | Corrección |
|---|---|---|
| Dos procesos entran a la vez. | Valor inicial mayor que uno, post extra o semáforos distintos. | Restablecer la disciplina y confirmar el objeto común. |
| Un proceso espera para siempre. | No habrá publicaciones, falta devolución o murió un participante. | Revisar protocolo y política de fallos; no publicar a ciegas. |
| Reabrir con valor uno no desbloquea. | El valor inicial no reconfigura un objeto existente. | Distinguir apertura, creación e intervención administrativa. |
| El nombre desapareció pero sigue habiendo acceso. | Referencias abiertas de una generación anterior. | Comprender que unlink no cancela usuarios existentes. |
| sem_wait falla y el contador cambia. | Se entró sin comprobar adquisición. | Separar la ruta de error de la sección crítica. |
| El total sigue perdiendo incrementos. | Lectura fuera de protección o participantes que omiten el semáforo. | Proteger la operación completa en todos los escritores. |
| Quedan nombres después de las pruebas. | Se cerraron referencias sin retirar nombres propios. | Asignar un responsable y verificar limpieza. |
La disciplina de nombres importa tanto como el balance de permisos. Si recreas un semáforo mientras usuarios antiguos siguen protegiendo los mismos datos con otra generación, cada grupo puede tener exclusión local y aun así violar la exclusión global.
18. Resumen
- Un semáforo representa permisos; sem_wait consume y sem_post publica.
- El valor inicial expresa el uso: exclusión, capacidad o notificación.
- sem_open devuelve sem_t * o SEM_FAILED, sin descriptor entero de aplicación.
- La creación exclusiva evita adoptar un objeto de propiedad desconocida.
- Abrir un semáforo existente no cambia su valor inicial.
- La sección crítica debe incluir la lectura-modificación-escritura completa.
- Solo una adquisición exitosa autoriza a entrar.
- Un post extra puede romper la exclusión aunque la llamada tenga éxito.
- sem_close cierra una referencia; sem_unlink retira un nombre.
- Ni cerrar ni morir devuelve automáticamente un permiso consumido.
- El contador protegido acepta únicamente una ejecución completa y supervisada.
- Consultar el valor no sustituye una adquisición.
19. Preguntas de repaso y práctica
Responde antes de desplegar cada explicación.
1. ¿Qué representa el valor de un semáforo?
Permisos disponibles según el protocolo elegido. No representa necesariamente procesos dentro, dueños ni resultados de tareas.
2. ¿Por qué se inicializa a uno para proteger el contador?
Para permitir una única adquisición simultánea, siempre que cada participante publique exactamente una vez al salir y no haya permisos adicionales.
3. ¿Un semáforo con valor inicial uno queda limitado automáticamente a uno?
No. Las publicaciones pueden aumentarlo. El uso binario depende de la disciplina del programa.
4. ¿Cómo se detecta un fallo de sem_open?
Comparando con SEM_FAILED y consultando errno. Su retorno no es un descriptor entero ni se debe asumir otro indicador de error.
5. ¿O_CREAT con valor uno reinicializa un semáforo existente?
No. Si ya existe, los argumentos de modo y valor no lo reconfiguran. O_EXCL permite exigir una creación realmente nueva.
6. ¿Qué se hace si sem_wait retorna EINTR en los ejemplos?
Se reintenta porque no hay una política de cancelación ligada a la señal. Todavía no se adquirió un permiso para entrar.
7. ¿Por qué no se publica después de una espera fallida?
Porque no se obtuvo una unidad que devolver. Publicar podría crear capacidad que el protocolo nunca concedió.
8. ¿Por qué esperar consume un permiso sin devolverlo en sem27?
Porque esa operación demuestra consumo de una notificación. La operación usar, en cambio, demuestra adquirir y devolver un permiso de exclusión.
9. ¿Por qué no basta proteger solo la escritura del contador?
Dos procesos podrían leer el mismo valor anterior antes de adquirir. Debe protegerse la secuencia completa que determina y reemplaza el nuevo valor.
10. ¿Qué diferencia hay entre sem_close y sem_unlink?
El primero cierra una referencia local; el segundo retira el nombre. Referencias ya abiertas pueden seguir usando el objeto tras retirar el nombre.
11. ¿Por qué se retira el nombre antes de fork en contador27?
Porque todos los usuarios heredarán la referencia abierta y no necesitan conectar por nombre. El objeto sigue vivo mientras existan esas referencias.
12. ¿La muerte de un trabajador devuelve el permiso?
No. El contador adopta fallo total: detecta la terminación, cancela a los demás y descarta los datos, en lugar de intentar recuperar con un post.
13. ¿sem_getvalue autoriza a entrar a la sección crítica?
No. Solo observa un estado que puede cambiar inmediatamente. La autorización procede de una adquisición exitosa.
14. ¿El puntero sem_t * puede copiarse al objeto compartido para conectar otro programa?
No como una referencia utilizable por un programa independiente. Ese programa debe abrir el semáforo por nombre y obtener su propia referencia local.
15. ¿Por qué el supervisor espera al hijo que termine en lugar de fijar un orden?
Para detectar pronto un trabajador fallido aunque otro esté bloqueado por un permiso perdido. Entonces puede cancelar y recoger a todos los pendientes.
Para practicar y ampliar
- Reproduce el evento con valor inicial cero, publicando antes y después de lanzar al consumidor.
- Publica dos unidades y comprueba que dos consumidores pueden gastarlas sin publicaciones adicionales.
- Usa dos terminales para conservar y devolver un permiso de exclusión sin sleeps.
- En el simulador, introduce un post extra y explica por qué la API puede aceptarlo aunque se rompa la invariancia.
- Ejecuta el contador con uno, dos y ocho trabajadores y verifica el producto esperado.
- Simula la caída de un hijo mientras conserva el permiso y comprueba la cancelación del resto.
- Explica por qué recrear un nombre no reconecta las referencias antiguas.
- Diseña una limitación de tres plazas: qué significa adquirir y cuándo se devuelve cada unidad.
- Identifica qué información adicional necesitarías para asociar cada permiso de notificación con datos concretos.
- Compara qué cambia al ubicar un semáforo sin nombre dentro de la región compartida, anticipando el tema siguiente.
El tema 28 presentará semáforos sin nombre en memoria compartida: sem_init con pshared, ubicación de sem_t, inicialización única y sem_destroy cuando ya no haya usuarios.