← Comunicación entre ProcesosBloque 7 · Semáforos POSIX entre procesos · Tema 28 de 52

Tema 28

Semáforos sin nombre en memoria compartida

Ya sabes coordinar procesos con un semáforo identificado por nombre. Ahora vas a colocar el propio sem_t dentro de una región compartida, inicializarlo una sola vez y utilizarlo desde los procesos que acceden a esa región. Aprenderás qué significa pshared, cómo preparar varios semáforos y cuándo es seguro destruirlos antes de liberar su almacenamiento.

1. Un semáforo alojado en la región

En el tema 27 sem_open creaba o abría un recurso con nombre y devolvía una referencia local. El contador estaba en una región compartida distinta. Ahora almacenaremos el semáforo y los datos que protege dentro de la misma región.

distribución nativa · un objeto sem_t y los datos de aplicación
struct region {
    sem_t mutex;
    uint64_t contador;
};

El programa reserva espacio para la estructura completa. El proceso responsable inicializa mutex con sem_init. Los demás utilizan la dirección del miembro dentro de su propia vista de la región.

Un semáforo sin nombre se identifica por el objeto sem_t situado en almacenamiento compartido, no por un nombre pasado a sem_open. Todos deben operar sobre ese mismo objeto, sin copiarlo.

DecisiónCon nombreSin nombre entre procesos
Preparación.sem_open con creación.Reservar almacenamiento compartido y llamar a sem_init.
Conexión.Abrir el nombre o heredar una referencia.Acceder a la región que contiene el objeto.
Espera y publicación.sem_wait y sem_post.Las mismas operaciones sobre la dirección local del miembro.
Finalización.sem_close y retirada del nombre con sem_unlink.sem_destroy una vez que no quedan usuarios; después liberar la región.

El almacenamiento puede ser anónimo y heredarse con fork, o proceder de un objeto de memoria compartida con nombre. Que el respaldo tenga un nombre no convierte al semáforo que contiene en uno abierto mediante sem_open.

2. sem_init y sem_destroy

interfaces · declaradas en semaphore.h
int sem_init(sem_t *s, int pshared, unsigned int valor);
int sem_destroy(sem_t *s);

Ambas funciones retornan cero al tener éxito y −1 al fallar, con el motivo en errno. sem_init recibe la dirección de almacenamiento que ya existe: no devuelve un nuevo sem_t * como sem_open.

pshared igual a cero selecciona uso entre hilos de un mismo proceso. Un valor distinto de cero selecciona uso entre procesos y requiere que el objeto esté en memoria realmente compartida. Usaremos el valor 1 para expresarlo, según sem_init(3).

fragmento · inicialización de exclusión entre procesos
if (sem_init(&r->mutex, 1, 1) == -1) {
    perror("sem_init");
    /* No utilizar ni destruir un semaforo cuya inicializacion fallo. */
}

Los dos unos tienen significados distintos. El segundo argumento elige el ámbito entre procesos; el tercero establece un permiso inicial para exclusión. Un canal de notificación podría usar pshared igual a 1 y valor inicial cero.

Algunos sistemas pueden no soportar semáforos compartidos entre procesos y devolver ENOSYS. Un valor inicial fuera de los límites puede producir EINVAL. Los ejemplos comprueban el retorno y no continúan suponiendo que todos los entornos tienen idéntico soporte.

3. Dos condiciones para compartir entre procesos

Ubicación de sem_tpsharedInterpretación
Variable privada en pila o heap habitual.0.Puede servir para hilos del mismo proceso; no es coordinación entre procesos.
Variable privada después de fork.1.Configuración incorrecta: el argumento no transforma la memoria privada en compartida.
Región MAP_SHARED.0.No se configura para comunicar procesos; no debe usarse así aunque alguna prueba parezca funcionar.
Región MAP_SHARED.1.Combinación apropiada para el objetivo de este tema, con inicialización y ciclo de vida correctos.

fork no convierte una variable global ordinaria en compartida. Si colocas sem_t en una variable privada y cada hijo modifica su copia, ya no estás usando el mismo almacenamiento del semáforo.

MAP_PRIVATE tampoco sirve para construir este canal. Aunque las vistas comiencen con contenido parecido, sus escrituras privadas no constituyen el objeto compartido que requiere el protocolo.

Una prueba sin contención puede no revelar una configuración equivocada. No aceptes como demostración que «el primer sem_wait no se bloqueó». Importan tanto la ubicación del objeto como la configuración de las operaciones de espera entre procesos.

4. Ubicación, alineación y objeto opaco

Coloca sem_t como un miembro normal de una estructura nativa y reserva sizeof de la estructura. El compilador determinará su alineación y el padding que necesita. No fuerces un empaquetado que deje el semáforo desalineado.

Dos vistas del mismo semáforo embebidoEl padre y el hijo acceden a la estructura compartida. Dentro están el semáforo mutex y el contador. Cada proceso forma la dirección local del miembro; no se comparte un puntero absoluto. Proceso padre&r->mutexProceso hijo&r->mutexRegion compartidasem_t mutexuint64_t contadormismo respaldo
Las referencias se obtienen desde cada vista local del mismo objeto en el respaldo compartido.

sem_t es opaco: no se editan sus campos internos, no se serializa como los enteros del catálogo del tema 25 y no se copia con una asignación de estructuras o memcpy después de inicializarlo.

El tamaño y la representación pueden depender de la implementación y ABI. Los participantes que comparten una estructura nativa con sem_t deben utilizar un entorno compatible. Una marca de versión o sizeof coincidente no demuestra por sí sola toda la compatibilidad binaria.

Dos procesos independientes pueden tener bases distintas. Cada uno obtiene &r->mutex desde su propio mapeo. No es necesario que coincidan las direcciones virtuales ni que se almacene un puntero a mutex dentro de la región.

No hagas memset de toda la estructura después de sem_init. El cero binario no equivale a una inicialización POSIX y puede destruir el estado interno de un semáforo ya activo. Inicializa datos ordinarios de manera separada o realiza la preparación de bytes antes de crear los semáforos.

5. Inicialización única antes de fork

  1. Reservar la región compartida. Obtener un mapeo válido para la estructura completa.
  2. Preparar los datos. Asignar valores iniciales a los campos de aplicación.
  3. Inicializar cada semáforo una vez. Registrar cuáles tuvieron éxito.
  4. Crear participantes. Solo entonces ejecutar fork y permitir operaciones sobre los semáforos.

El padre es el único inicializador. Los hijos heredan el mapeo ya preparado y utilizan sus miembros. No ejecutan sem_init al entrar a su rama de código.

Reinicializar un semáforo que ya está inicializado tiene comportamiento indefinido. No es una forma de restaurar su valor ni de desbloquear esperadores. Tampoco debe decidirse que «todavía no está inicializado» observando bytes internos.

Si hay varios semáforos y falla la preparación del segundo, el programa destruye solo el primero, porque todavía no existen usuarios. Un indicador local de inicialización permite tomar esa decisión sin consultar un objeto inválido.

6. Usar, terminar usuarios y destruir

secuencia · propietario del almacenamiento y usuarios
PADRE                              HIJOS
mmap MAP_SHARED
inicializar datos
sem_init(..., 1, valor)
fork ----------------------------> utilizar sem_wait / sem_post
supervisar                         terminar operaciones
recoger todos <------------------ munmap de su vista y _exit
comprobar que no quedan usuarios
sem_destroy
munmap de la region

El hijo retira su mapeo al terminar, pero no destruye el semáforo común. Esa destrucción corresponde al responsable cuando sabe que no existe ningún usuario presente ni futuro de esa generación.

Destruir un semáforo con participantes bloqueados sobre él tiene comportamiento indefinido. sem_destroy no es una operación de cancelación ni una forma de despertar esperadores, como advierte sem_destroy(3).

El orden es importante: sem_destroy antes de liberar el almacenamiento que contiene el objeto. Después de munmap ya no se puede formar una referencia válida para destruirlo. El valor del semáforo no prueba que nadie vaya a usarlo.

Una ejecución que termina en error también debe resolver quiénes siguen vivos antes de destruir. Los programas de este tema cancelan a los hijos pendientes ante un fallo y los recogen antes de desmontar la región.

7. Código de apoyo y supervisión

Guarda apoyo28.h. Incluye validación de cantidades, espera de permisos con reintento de EINTR y un supervisor que recoge al hijo que termine. Ante fallo, cancela solo hijos todavía no recogidos.

La salida sin_usuarios confirma si se recogieron todos los hijos conocidos. Si esa condición no puede comprobarse, el padre no llama a sem_destroy como si la destrucción fuera segura.

apoyo28.h · recolección y cancelación antes de destruir
#ifndef APOYO28_H
#define APOYO28_H
#define _DEFAULT_SOURCE
#include <errno.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/wait.h>
#include <unistd.h>

struct hijo { pid_t pid; int recogido; };

static inline int numero(const char *s, 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 n = strtoul(s, &fin, 10);
    if (errno || *fin || n == 0 || n > maximo) return -1;
    *salida = (unsigned)n;
    return 0;
}

static inline int esperar_permiso(sem_t *s)
{
    int r;
    do { r = sem_wait(s); } while (r == -1 && errno == EINTR);
    return r;
}

static inline int recoger(struct hijo *h, unsigned n, int cancelar,
                          int *sin_usuarios)
{
    int fallo = cancelar;
    unsigned recogidos = 0;
    while (!fallo && recogidos < n) {
        int estado;
        pid_t pid;
        do { pid = waitpid(-1, &estado, 0); } while (pid == -1 && errno == EINTR);
        if (pid == -1) { perror("waitpid"); fallo = 1; break; }
        unsigned i = 0;
        while (i < n && h[i].pid != pid) ++i;
        if (i == n || h[i].recogido) {
            fprintf(stderr, "PID inesperado\n"); fallo = 1; break;
        }
        h[i].recogido = 1;
        ++recogidos;
        if (!WIFEXITED(estado) || WEXITSTATUS(estado) != 0) {
            fprintf(stderr, "Hijo fallido: se cancela la ejecucion\n");
            fallo = 1;
        }
    }
    if (fallo) {
        for (unsigned i = 0; i < n; ++i)
            if (!h[i].recogido && kill(h[i].pid, SIGKILL) == -1 && errno != ESRCH)
                perror("kill hijo pendiente");
        for (unsigned i = 0; i < n; ++i) {
            if (h[i].recogido) continue;
            int estado;
            pid_t pid;
            do { pid = waitpid(h[i].pid, &estado, 0); }
            while (pid == -1 && errno == EINTR);
            if (pid == -1) perror("waitpid limpieza");
            else h[i].recogido = 1;
        }
    }
    *sin_usuarios = 1;
    for (unsigned i = 0; i < n; ++i)
        if (!h[i].recogido) *sin_usuarios = 0;
    return fallo ? -1 : 0;
}
#endif

El supervisor se utiliza en programas independientes, de un solo hilo antes de fork, sin otros hijos ni recolectores. Se llama una vez por ejecución y conoce todas las referencias a la región. En otro servicio habría que incorporar al contrato cualquier usuario externo.

La cancelación no intenta restaurar permisos ni datos. Descarta la operación y asegura la terminación de los usuarios conocidos. Se envía SIGKILL a todos los pendientes antes de esperarlos, evitando quedar esperando uno mientras otro conserva un permiso perdido.

8. Programa: contador con semáforo embebido

Guarda contador28.c. El comportamiento esperado coincide con el contador del tema 27, pero ahora no hay sem_open, nombre de semáforo ni referencias que cerrar con sem_close.

contador28.c · un inicializador y destrucción después de los hijos
#include "apoyo28.h"

struct region {
    sem_t mutex;
    uint64_t contador;
};

static int trabajar(struct region *r, unsigned iteraciones)
{
    for (unsigned i = 0; i < iteraciones; ++i) {
        if (esperar_permiso(&r->mutex) == -1) return 2;
        uint64_t anterior = r->contador;
        r->contador = anterior + 1;
        if (sem_post(&r->mutex) == -1) return 3;
    }
    return 0;
}

int main(int argc, char **argv)
{
    unsigned cantidad, iteraciones;
    if (argc != 3 || numero(argv[1], 8, &cantidad) == -1 ||
        numero(argv[2], 1000000, &iteraciones) == -1) {
        fprintf(stderr, "Uso: %s trabajadores(1..8) iteraciones(1..1000000)\n",
                argv[0]);
        return EXIT_FAILURE;
    }
    struct region *r = mmap(NULL, sizeof *r, PROT_READ | PROT_WRITE,
                            MAP_SHARED | MAP_ANONYMOUS, -1, 0);
    if (r == MAP_FAILED) { perror("mmap"); return EXIT_FAILURE; }
    r->contador = 0;
    int inicializado = 0, fallo = 0, sin_usuarios = 1;
    struct hijo hijos[8];
    unsigned creados = 0;
    if (sem_init(&r->mutex, 1, 1) == -1) {
        perror("sem_init"); fallo = 1; goto fin;
    }
    inicializado = 1;
    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(r, iteraciones);
            /* Un usuario retira su vista, no destruye el objeto comun. */
            if (munmap(r, sizeof *r) == -1) codigo = 4;
            _exit(codigo);
        }
        hijos[creados++] = (struct hijo){pid, 0};
    }

fin:
    if (recoger(hijos, creados, fallo, &sin_usuarios) == -1) fallo = 1;
    if (!fallo) {
        uint64_t esperado = (uint64_t)cantidad * iteraciones;
        printf("Hijos recogidos: %u\nEsperado: %" PRIu64 "\nContador: %" PRIu64 "\n",
               creados, esperado, r->contador);
        if (r->contador != esperado) fallo = 1;
    }
    if (inicializado && sin_usuarios) {
        if (sem_destroy(&r->mutex) == -1) {
            perror("sem_destroy"); fallo = 1;
        }
    } else if (inicializado) {
        fprintf(stderr, "No se destruye: no se confirmo el fin de usuarios\n");
        fallo = 1;
    }
    if (munmap(r, sizeof *r) == -1) { perror("munmap padre"); fallo = 1; }
    return fallo ? EXIT_FAILURE : EXIT_SUCCESS;
}

El indicador inicializado solo se activa después del retorno cero de sem_init. Si falla, no se invoca sem_destroy sobre ese almacenamiento. Como aún no se crearon hijos, la limpieza puede retirar inmediatamente el mapeo.

El padre lee el contador después de la recolección correcta. El semáforo protege las modificaciones durante el trabajo; la recolección fija el momento de consulta final. No hace falta volatile ni sincronización mediante demoras.

9. Compilar y verificar el contador

Bash en Linux o WSL · cabecera y fuente en el mismo directorio
$ gcc -std=c17 -O2 -Wall -Wextra -Wpedantic contador28.c -o contador28 -pthread
$ ./contador28 2 100000
Hijos recogidos: 2
Esperado: 200000
Contador: 200000
$ ./contador28 8 1000
Hijos recogidos: 8
Esperado: 8000
Contador: 8000

La opción -pthread configura la compilación y el enlace para estas interfaces. La macro _DEFAULT_SOURCE de la cabecera expone MAP_ANONYMOUS en glibc con C17 estricto.

La cantidad máxima es ocho millones de incrementos, representable en uint64_t. La aceptación no depende de un orden alternado de los trabajadores: cada incremento protegido conserva la contribución anterior.

No aparecerá un nombre sem.ipc28 en /dev/shm porque no se creó un semáforo con nombre. La región de estos ejemplos también es anónima; su vida útil depende de las vistas que conserva la familia de procesos.

10. Un canal de una sola casilla

Un segundo ejemplo permitirá observar dos semáforos en la misma región. Un productor escribe números consecutivos en una casilla y un consumidor verifica su secuencia y suma sus cuadrados. Solo puede existir un valor pendiente en cada momento.

SemáforoValor inicialSignificado
libre.1.El productor puede escribir en la casilla.
datos.0.Hay una unidad disponible para consumir.
protocolo · transferencia del derecho a acceder a la casilla
PRODUCTOR                           CONSUMIDOR
esperar libre                       esperar datos
escribir valor                      leer y validar valor
publicar datos                      publicar libre

PADRE
inicializar libre y datos antes de fork
esperar a ambos hijos
verificar la suma
destruir datos y libre
retirar su mapeo

El productor no sobrescribe hasta recibir libre de nuevo. El consumidor no lee hasta adquirir datos. El permiso comunica que la fase anterior terminó, evitando que ambos accedan de manera conflictiva a la casilla.

No hay un mutex adicional porque existe un productor, un consumidor y una sola casilla con propiedad transferida por las dos esperas. Con varios productores o consumidores habría que volver a analizar la propiedad de cada campo y los índices.

La cantidad de elementos es conocida por ambos hijos. No necesitamos todavía mensajes de fin ni un búfer circular; esos elementos se integrarán en el proyecto del tema 30.

11. Programa: productor y consumidor

Guarda canal28.c. Acepta entre 1 y 1000 elementos. El padre inicializa ambos semáforos antes de lanzar hijos, registra cuántas inicializaciones tuvieron éxito y utiliza el supervisor de la cabecera.

canal28.c · semáforos de casilla libre y dato disponible
#include "apoyo28.h"

struct canal {
    sem_t libre;
    sem_t datos;
    uint64_t valor;
    uint64_t suma;
};

static int producir(struct canal *r, unsigned cantidad)
{
    for (unsigned i = 1; i <= cantidad; ++i) {
        if (esperar_permiso(&r->libre) == -1) return 2;
        r->valor = i;
        if (sem_post(&r->datos) == -1) return 3;
    }
    return 0;
}

static int consumir(struct canal *r, unsigned cantidad)
{
    uint64_t suma = 0;
    for (unsigned i = 1; i <= cantidad; ++i) {
        if (esperar_permiso(&r->datos) == -1) return 4;
        uint64_t valor = r->valor;
        if (valor != i) return 5;
        suma += valor * valor;
        if (sem_post(&r->libre) == -1) return 6;
    }
    r->suma = suma;
    return 0;
}

int main(int argc, char **argv)
{
    unsigned cantidad;
    if (argc != 2 || numero(argv[1], 1000, &cantidad) == -1) {
        fprintf(stderr, "Uso: %s elementos(1..1000)\n", argv[0]);
        return EXIT_FAILURE;
    }
    struct canal *r = mmap(NULL, sizeof *r, PROT_READ | PROT_WRITE,
                           MAP_SHARED | MAP_ANONYMOUS, -1, 0);
    if (r == MAP_FAILED) { perror("mmap"); return EXIT_FAILURE; }
    r->valor = 0;
    r->suma = 0;
    sem_t *semaforos[2] = {&r->libre, &r->datos};
    unsigned valores[2] = {1, 0};
    unsigned inicializados = 0, creados = 0;
    int fallo = 0, sin_usuarios = 1;
    struct hijo hijos[2];
    for (unsigned i = 0; i < 2; ++i) {
        if (sem_init(semaforos[i], 1, valores[i]) == -1) {
            perror("sem_init canal"); fallo = 1; goto fin;
        }
        ++inicializados;
    }
    for (unsigned i = 0; i < 2; ++i) {
        pid_t pid = fork();
        if (pid == -1) { perror("fork"); fallo = 1; goto fin; }
        if (pid == 0) {
            int codigo = i == 0 ? producir(r, cantidad) : consumir(r, cantidad);
            if (munmap(r, sizeof *r) == -1) codigo = 7;
            _exit(codigo);
        }
        hijos[creados++] = (struct hijo){pid, 0};
    }

fin:
    if (recoger(hijos, creados, fallo, &sin_usuarios) == -1) fallo = 1;
    if (!fallo) {
        uint64_t n = cantidad;
        uint64_t esperado = n * (n + 1) * (2 * n + 1) / 6;
        printf("Elementos: %u\nSuma de cuadrados: %" PRIu64 "\nEsperado: %" PRIu64 "\n",
               cantidad, r->suma, esperado);
        if (r->suma != esperado) fallo = 1;
    }
    if (sin_usuarios) {
        while (inicializados > 0) {
            --inicializados;
            if (sem_destroy(semaforos[inicializados]) == -1) {
                perror("sem_destroy canal"); fallo = 1;
            }
        }
    } else {
        fprintf(stderr, "No se destruye: no se confirmo el fin de usuarios\n");
        fallo = 1;
    }
    if (munmap(r, sizeof *r) == -1) { perror("munmap padre"); fallo = 1; }
    return fallo ? EXIT_FAILURE : EXIT_SUCCESS;
}

El array semaforos contiene punteros locales para recorrer los dos miembros durante preparación y limpieza. No se guarda ese array en la región ni se copia su contenido a otro proceso para conectarlo.

El consumidor mantiene la acumulación en una variable privada y publica suma al terminar. El padre no consulta ese campo hasta recoger a ambos hijos. Las operaciones sobre valor, en cambio, se coordinan durante todo el intercambio.

Si falla la segunda inicialización, inicializados vale uno y se destruye solamente libre. Si falla el segundo fork, el productor existente puede estar esperando libre: el supervisor lo cancela y recoge antes de destruir los semáforos.

12. Verificar el intercambio y sus invariantes

Bash · entradas mínimas y más intercambios que capacidad
$ gcc -std=c17 -O2 -Wall -Wextra -Wpedantic canal28.c -o canal28 -pthread
$ ./canal28 1
Elementos: 1
Suma de cuadrados: 1
Esperado: 1
$ ./canal28 10
Elementos: 10
Suma de cuadrados: 385
Esperado: 385
$ ./canal28 1000
Elementos: 1000
Suma de cuadrados: 333833500
Esperado: 333833500

El resultado usa la suma de cuadrados de 1 a N: N × (N + 1) × (2N + 1) / 6. Con el límite de 1000 los valores intermedios caben en uint64_t. No se aceptan cantidades externas sin límite antes de multiplicar.

La casilla es de capacidad uno, pero puede transportar mil unidades porque sus permisos se reutilizan. No se necesita reservar un array para todos los valores ni enviar un permiso que corresponda a contenido todavía no escrito.

FaseQuién puede actuar sobre valorQué cambia de permiso
Casilla disponible.Productor después de adquirir libre.Retira el derecho a sobrescribir de otro turno.
Valor escrito.El productor ya terminó su acceso.Publica datos para habilitar al consumidor.
Valor disponible.Consumidor después de adquirir datos.Consume la unidad pendiente.
Lectura terminada.El consumidor ya no necesita el valor.Publica libre para el próximo turno.

Durante el trabajo puede haber un permiso adquirido que todavía no se haya publicado en el otro semáforo. Por eso no se impone que una consulta aislada muestre siempre libre + datos igual a uno. La invariancia describe el derecho a utilizar la casilla, incluyendo al participante que está procesando una transición.

Al terminar normalmente, el último dato ya fue consumido y libre volvió a publicarse. Sin embargo, para decidir la destrucción utilizamos la terminación de usuarios, no el valor final de esos contadores.

13. Procesos independientes y publicación de la región

Un semáforo sin nombre también puede ser usado por procesos independientes si está dentro de un objeto de memoria compartida al que todos conectan. La ausencia de un nombre de semáforo no exige parentesco; exige localizar el mismo almacenamiento.

secuencia de diseño · objeto shm_open con un sem_t embebido
CREADOR
shm_open con O_CREAT | O_EXCL y O_RDWR
ftruncate al tamano nativo acordado
mmap MAP_SHARED, PROT_READ | PROT_WRITE
inicializar datos y sem_init(..., 1, valor), una sola vez
publicar la disponibilidad mediante un protocolo externo

PARTICIPANTE
shm_open existente con O_RDWR
fstat y comprobar contrato de distribucion
mmap MAP_SHARED, PROT_READ | PROT_WRITE
esperar confirmacion de inicializacion antes de usar sem_t
sem_wait / sem_post sobre el miembro local
munmap al desconectarse; no sem_destroy por su cuenta

Incluso un consumidor que solo lee los datos de aplicación necesita poder modificar el almacenamiento del semáforo al hacer sem_wait y sem_post. Un mapeo PROT_READ de la estructura entera no basta para esas operaciones.

El tamaño correcto, una marca ordinaria o el simple hecho de encontrar el nombre no garantizan que sem_init haya terminado. El creador exclusivo elige quién prepara el objeto, pero no vuelve atómica la secuencia completa de preparación y publicación.

Una solución inicial puede ejecutar participantes solo después del éxito del creador, como en los temas 24 y 25. Un servicio concurrente necesita otro canal o un protocolo de arranque ya establecido. No se puede esperar sobre el propio semáforo todavía no inicializado para averiguar si su inicialización terminó.

El responsable de destruir debe saber que todos los participantes independientes se desconectaron y que ninguno podrá volver a operar sobre esa generación. Recoger hijos con waitpid solo demuestra la salida de esos hijos, no la de clientes ajenos.

El nombre del objeto compartido se gestiona con shm_unlink y su descriptor con close. Esas operaciones no sustituyen sem_destroy. El mecanismo de conexión a regiones se describe en shm_open(3).

14. Inicialización parcial y rutas de error

Punto de falloEstado realLimpieza válida
mmap.No hay región utilizable.No acceder, no inicializar y no destruir.
Primer sem_init.Ningún semáforo confirmado como inicializado.Retirar el mapeo, sin sem_destroy sobre ese objeto.
Segundo sem_init.El primero está preparado; aún no hay usuarios.Destruir solo el primero y retirar la región.
fork intermedio.Hay semáforos y algunos hijos conocidos.Cancelar y recoger hijos; después destruir los inicializados.
Trabajo de un hijo.Puede haber un permiso o dato incompleto.Descartar la ejecución, terminar usuarios y destruir.
Recolección no confirmada.No se pudo demostrar que todos salieron.No efectuar una destrucción suponiendo ausencia de usuarios.

El registro de inicialización pertenece al responsable de preparar y desmontar. No es una bandera compartida para que cualquier proceso compita por inicializar «si está a cero».

Los programas destruyen en orden inverso a la preparación por claridad. Lo esencial es destruir únicamente objetos inicializados y hacerlo cuando ya no haya usuarios, no el orden nominal de los dos miembros.

La rama hija no tiene responsabilidad de rollback de la inicialización global. Su responsabilidad es dejar de usar los objetos y terminar. Si destruyera un semáforo al salir mientras otro hijo continúa, rompería el contrato del grupo.

En una aplicación larga hay que tratar también fallos de la propia destrucción y de liberación. No se reutiliza a ciegas un sem_t cuyo desmontaje no se comprende. Los ejemplos informan el error y finalizan sin presentar la operación como exitosa.

15. Destrucción y límites de recuperación

sem_destroy no comprueba por ti todo el protocolo de vida útil. No debes provocar una destrucción con esperadores para comprobar si la biblioteca devuelve EBUSY: la precondición ya se incumplió y no existe esa garantía general de detección.

Consultar sem_getvalue tampoco demuestra que no haya usuarios. Un valor disponible no excluye que otro participante esté a punto de ejecutar sem_wait; un valor cero tampoco distingue todas las razones por las que falta un permiso.

Una terminación anormal puede dejar un semáforo sin permisos. Después de cancelar y recoger a todos los usuarios conocidos, se puede destruir el objeto inicializado aunque no haya vuelto al valor inicial. La precondición importante es la ausencia de usuarios y esperadores, no restablecer artificialmente el contador.

Los ejemplos aplican fallo total. No publican permisos extra para salvar una ejecución parcial ni reinicializan el objeto mientras hay procesos vivos. Un servicio que deba continuar tras una caída necesitaría un diseño explícito de consistencia y recuperación.

No hay un plazo global de supervisión: un hijo suspendido sin terminar puede mantener al padre esperando. Las esperas temporales y las políticas de recuperación se abordarán en el tema 29. Una caída abrupta del padre tampoco ejecuta sus llamadas a sem_destroy.

Si un padre retira su propia vista sin destruir porque no logró confirmar la salida de todos, eso no retira las vistas de los demás. Se evita la destrucción insegura, pero no se promete una limpieza global completa en una situación fuera de las condiciones del supervisor.

16. Explorar el ciclo de vida

El modelo permite intentar operaciones en orden correcto o incorrecto. Primero reserva la región, inicializa y lanza dos usuarios. Después puedes representar esperadores y terminar al grupo antes de destruir. Los intentos inválidos se rechazan didácticamente, sin ejecutar comportamiento indefinido real.

Región del responsableNo reservada

SemáforoNo inicializado

Usuarios y esperadores0 usuarios; 0 esperadores

Responsabilidad pendienteReservar almacenamiento

La ubicación y pshared deben corresponder al uso entre procesos.

«Terminar y recoger usuarios» representa una fase completa del supervisor. Si había esperadores, incluye cancelarlos y confirmar su terminación; no presupone que sem_destroy los despertó. Este modelo estudia vida útil, no el balance interno de permisos.

Cambiar almacenamiento o pshared reinicia el experimento. La configuración de hilos puede inicializar un semáforo local válido, pero el modelo no permite usarlo como si fuera coordinación entre procesos.

17. Pruebas, observación y diagnóstico

Comprobar resultados sin depender del reparto

Bash · tamaños mínimos y reiteración del intercambio
$ ./contador28 1 1
Hijos recogidos: 1
Esperado: 1
Contador: 1
$ for prueba in 1 2 3 4 5; do ./canal28 1000 || exit 1; done
$ ./canal28 0
Uso: ./canal28 elementos(1..1000)

Prueba entradas no numéricas, negativas y fuera de rango. Deben rechazarse antes de crear la región. Para el contador valida cantidad × iteraciones; para el canal valida orden de elementos y suma, no solo el número de operaciones terminadas.

Inyectar fallos con recursos propios

No pruebes configuraciones incorrectas de pshared, destrucciones activas o copias de sem_t esperando un error seguro. Analiza esos casos con el simulador o revisa el código: algunas violaciones no tienen un resultado definido que un test pueda exigir.

Observar esperas y accesos

Bash · seguir a ambos participantes del canal
$ strace -f -e trace=mmap,munmap,futex,clone,fork,vfork,wait4 ./canal28 10

La traza puede mostrar mapeos, bloqueos, creación de hijos y esperas. No esperes una llamada al sistema sem_init ni un futex por cada sem_wait: parte del trabajo puede resolverse en la biblioteca sin entrar al núcleo.

Los mecanismos generales de espera y publicación son los mismos que en el tema anterior. Lo que cambia aquí es dónde vive el semáforo, cómo se inicializa y quién puede destruirlo. La distinción entre ambas clases se resume en sem_overview(7).

SíntomaRevisiónDecisión correcta
Solo funciona sin contención.Ubicación y pshared.Objeto realmente compartido y configuración entre procesos.
Un hijo empieza con otro estado.Se inicializó después de fork o en cada hijo.Un inicializador antes de admitir usuarios.
El consumidor lee valores repetidos.Permisos de casilla y acceso fuera de fase.Esperar datos antes de leer y libre antes de sobrescribir.
La limpieza llama a sem_close.Se mezclaron clases de semáforo.sem_destroy para el objeto inicializado con sem_init.
Se pierde el objeto al retirar una vista.Se intenta destruir después de munmap.Destruir antes de liberar su almacenamiento, sin usuarios.
Se bloquea la recuperación.Hay un usuario vivo detenido o un permiso perdido.Definir supervisión y cancelación; no reinicializar a ciegas.

18. Resumen

19. Preguntas de repaso y práctica

Responde antes de desplegar las explicaciones.

1. ¿Qué cambia respecto de un semáforo con nombre?

La aplicación reserva el almacenamiento del sem_t y lo inicializa con sem_init. No se obtiene una referencia mediante sem_open ni se administra un nombre de semáforo.

2. ¿Qué significan los dos unos de sem_init(&r->mutex, 1, 1)?

El primero configura uso entre procesos; el segundo concede un permiso inicial para exclusión. Son parámetros con funciones distintas.

3. ¿pshared igual a uno basta si sem_t está en la pila?

No. El objeto debe estar en memoria realmente compartida. El argumento no cambia la clase de almacenamiento.

4. ¿Por qué no se usa pshared cero entre padre e hijo?

Porque esa configuración corresponde a hilos de un mismo proceso. Que los bytes estén en un mapeo compartido no cambia el ámbito seleccionado para el semáforo.

5. ¿Puede cada hijo llamar a sem_init al empezar?

No sobre el mismo objeto ya inicializado. El responsable lo prepara una sola vez antes de admitir usuarios; reinicializarlo activo tiene comportamiento indefinido.

6. ¿Por qué sem_t se coloca como miembro normal de una estructura?

Para que el compilador respete su alineación y tamaño nativos. No se debe empaquetar ni manipular su representación interna.

7. ¿Se puede copiar la estructura después de inicializar los semáforos?

No para crear otro objeto utilizable por copia de sem_t. Los usuarios deben acceder al objeto original en el respaldo compartido.

8. ¿Por qué el hijo solo ejecuta munmap al terminar?

Retira su vista local. Destruir el semáforo común mientras otro usuario sigue operando sería una violación del ciclo de vida.

9. ¿Cuándo es seguro ejecutar sem_destroy?

Cuando el semáforo fue inicializado correctamente y se ha establecido que no quedan usuarios ni esperadores y que no podrán aparecer nuevos usos de esa generación.

10. ¿sem_destroy debe devolver un error si hay esperadores?

No se puede depender de eso. Destruir con procesos o hilos bloqueados incumple la precondición y tiene comportamiento indefinido.

11. ¿Qué se limpia si falla el segundo sem_init?

Solo el primer semáforo que terminó de inicializarse y el almacenamiento reservado, siempre antes de que existan usuarios.

12. ¿Por qué el canal no necesita otro mutex para la casilla?

Porque un único productor y un único consumidor transfieren el derecho a acceder mediante libre y datos. No pueden sobrescribir y leer la casilla de manera conflictiva si respetan ese protocolo.

13. ¿Un lector independiente puede mapear toda la estructura con PROT_READ?

No si va a ejecutar sem_wait o sem_post sobre el semáforo embebido, porque esas operaciones modifican su almacenamiento. Necesita acceso de escritura al área correspondiente.

14. ¿Un valor inicial recupera automáticamente un objeto tras una caída?

No. No debe reinicializarse mientras haya usuarios. Los ejemplos cancelan, recogen, descartan el estado y destruyen al final.

15. ¿Un nombre shm_open hace que el semáforo interno tenga nombre?

No. El nombre localiza la región, pero el semáforo interno se creó con sem_init y se destruye con sem_destroy.

Para practicar y ampliar

  1. Compara contador27 y contador28 e identifica qué operaciones de preparación y limpieza cambian.
  2. Dibuja la vida del miembro mutex desde mmap hasta el munmap final.
  3. Ejecuta el contador con uno y ocho hijos y comprueba el total sin exigir alternancia.
  4. Calcula a mano los permisos y el propietario de la casilla durante tres intercambios del canal.
  5. Simula el fallo de la segunda inicialización y comprueba qué sem_destroy debe ejecutarse.
  6. Simula el fallo del segundo fork y la salida anormal de un consumidor con un permiso adquirido.
  7. Usa el explorador para intentar destruir con usuarios y retirar almacenamiento antes de destruir.
  8. Diseña una conexión a un objeto shm_open con el mismo sem_t embebido, explicando cómo confirmarías la inicialización.
  9. Explica por qué una versión de datos portable no convierte sem_t en una representación portable entre bibliotecas.
  10. Propón cómo pasar de una casilla a un búfer circular, identificando qué índices y permisos adicionales habrá que coordinar.
Próximo paso

El tema 29 estudiará esperas, errores y recuperación: sem_trywait, sem_timedwait, EINTR y qué límites aparecen cuando un proceso muere mientras conserva un permiso.