← Comunicación entre ProcesosBloque 5 · Colas de mensajes · Tema 22 de 52

Tema 22

Proyecto: reparto de tareas con una cola

Vas a construir un supervisor que reparte tareas entre varios procesos, identifica sus resultados y coordina su terminación. El proyecto utiliza una cola de trabajo compartida, otra de resultados y notificación con mq_notify. El reto será mantener el progreso con capacidad finita, rearmar los avisos sin perder llegadas y confirmar el trabajo aceptado antes de detener a los trabajadores.

1. Contrato del proyecto

Los temas 19 a 21 presentaron unidades de mensaje, creación de colas, prioridades y esperas. Ahora integraremos esas piezas en un programa que genera tareas numeradas y reparte su cálculo entre procesos hijos.

La tarea i calcula i × i. El supervisor genera entre 1 y 1000 tareas y crea entre uno y ocho trabajadores. Cada resultado identifica la tarea y el trabajador que lo produjo. El supervisor comprueba el valor y rechaza resultados duplicados o ajenos a las tareas ya aceptadas.

El programa distingue tareas previstas, tareas aceptadas por la cola y tareas confirmadas mediante resultados. La parada normal espera las confirmaciones antes de enviar el fin a los trabajadores.

La demora opcional de cada cálculo, de cero a 50 ms, simula un trabajo de duración visible. No sincroniza procesos ni garantiza un reparto equilibrado. El programa impone además un presupuesto global monotónico de 60 segundos para no supervisar indefinidamente una ejecución sin progreso.

2. Colas de tareas y resultados

Los trabajadores compiten por una cola compartida de tareas. Una segunda cola transporta resultados al supervisor. Solo este último consume resultados y registra su notificación.

Supervisor y trabajadores comunicados por dos colasEl supervisor produce tareas en una cola compartida. Tres trabajadores retiran tareas, calculan y envían resultados a otra cola. El supervisor recibe esos resultados y registra mq_notify sobre esa segunda cola. Supervisorproduce y confirmaCola de tareascapacidad: 4Cola de resultadoscapacidad: 4Trabajador 1Trabajador 2Trabajador 3
La notificación corresponde a resultados; los trabajadores esperan tareas con recepción bloqueante.

Ambas colas tienen cuatro plazas de 16 bytes. La cantidad total de tareas puede superar esa capacidad porque los participantes intercalan sus operaciones. Ningún proceso necesita mantener una copia ilimitada de solicitudes pendientes.

El supervisor abre referencias no bloqueantes para producir tareas y recibir resultados. Antes de retirar los nombres, abre también las referencias bloqueantes que heredarán los trabajadores. Son aperturas distintas: no cambiamos O_NONBLOCK en una referencia compartida para transformar el rol del hijo.

3. Mensajes identificados y codificación explícita

BytesContenidoInterpretación
0.Versión 1.Se valida antes de interpretar campos.
1.Clase.1 tarea, 2 fin, 3 resultado.
2–3.Reservados a cero.Se rechazan valores inesperados.
4–7.Identificador de tarea.Entero de 32 bits, byte más significativo primero.
8–11.Valor.Entrada i o resultado i × i.
12–15.Trabajador.Cero en la tarea; índice 1..N en su resultado.

Los mensajes de fin dejan a cero los campos numéricos. Todas las unidades tienen 16 bytes y prioridad cero. El máximo de 1000 mantiene los cuadrados dentro de uint32_t.

No enviamos una estructura nativa con enteros o punteros. La cabecera define cómo codificar y leer los campos. La longitud externa de cada recepción debe ser exactamente 16 antes de acceder al formato.

4. Competencia entre trabajadores y confirmaciones

Una recepción correcta retira una tarea para un trabajador. Los otros no reciben una copia. Tampoco hay un turno fijo: un proceso rápido puede retirar varias tareas y otro puede no recibir ninguna antes de la fase final.

El supervisor considera confirmada una tarea cuando recibe su resultado válido. Mantiene un registro de identificadores confirmados, no solo un contador: dos resultados repetidos no deben ocultar una tarea ausente.

La cola de tareas vacía no demuestra que el trabajo haya terminado. Puede haber tareas ya retiradas que todavía se calculan o resultados que aún no llegaron al supervisor. La recepción de mensajes se describe en mq_receive(3).

5. Evitar la espera circular entre colas

El diseño peligroso consiste en enviar todas las tareas de forma bloqueante y recién después leer resultados. El supervisor puede llenar tareas mientras los trabajadores llenan resultados: los primeros esperan que se consuman resultados y el supervisor espera que se consuman más tareas.

El bucle del proyecto drena resultados y admite tareas por turnos. Cuando mq_send devuelve EAGAIN, conserva la tarea todavía no aceptada y atiende resultados y eventos. Solo avanza el identificador de envío tras un retorno cero.

Los trabajadores pueden bloquearse al emitir un resultado porque el supervisor sigue consumiendo esa cola. Esta dependencia tiene una salida; el supervisor no queda bloqueado intentando producir tareas. Los retornos del envío se documentan en mq_send(3).

6. Qué hace y qué no hace mq_notify

mq_notify registra un aviso cuando una cola vacía recibe un mensaje. En este proyecto utiliza SIGEV_SIGNAL y entrega SIGRTMIN al supervisor. La llamada no retira el mensaje ni ejecuta el procesamiento.

Por eso el supervisor recibe resultados de manera no bloqueante y ningún trabajador compite por esa cola como lector. El contrato de notificación está en mq_notify(3).

7. Rearmar antes de drenar

El orden al atender un aviso es registrar la siguiente notificación y después consumir hasta EAGAIN. Si ya hay contenido cuando se registra, no se espera un aviso por ese contenido: se intenta recibir de inmediato.

patrón · sin depender de contar señales
/* La notificacion anterior ya fue consumida. */
mq_notify(resultados, &evento);  /* comprobar el resultado */
for (;;) {
    /* Recibir no bloqueante y procesar cada unidad. */
    /* Terminar el drenado al obtener EAGAIN. */
}
/* Esperar eventos sin desbloquear la senal de aviso. */

Si se drena primero y se registra después, puede llegar un mensaje en el intervalo sin registro. Al registrar sobre una cola que ya contiene ese mensaje, el programa podría esperar un aviso futuro mientras dejó contenido sin atender.

En el orden correcto, una llegada durante el drenado se consume o deja una señal pendiente. Una señal puede atenderse cuando el contenido ya fue retirado por el propio supervisor; eso no es pérdida: se rearma y se vuelve a drenar hasta observar el estado real.

8. Recibir avisos y control mediante señales bloqueadas

El supervisor bloquea SIGRTMIN, SIGCHLD, SIGINT y SIGTERM antes de crear hijos y registrar notificaciones. Después las recibe de manera síncrona con sigtimedwait, sin un manejador que deba imprimir o tocar las colas.

Una señal que llegue antes de la espera queda pendiente. El bucle también revisa señales sin esperar entre fases de trabajo. SIGCHLD invita a consultar waitpid; no equivale a un hijo por aviso.

Los trabajadores mantienen bloqueadas esas señales de control y terminan por su mensaje de fin. Así Ctrl+C sobre el grupo de terminal no los mata antes de que el supervisor pueda cerrar la producción y completar las tareas admitidas. Ante una cancelación por fallo, el supervisor usa SIGKILL sobre sus hijos directos.

El programa es independiente y de un solo hilo antes de fork. No intenta imponer esta política a una aplicación externa. La recepción síncrona se documenta en sigwaitinfo(2) y sigtimedwait(2).

9. Protocolo de parada ordenada

  1. Cerrar la producción. En ejecución normal se alcanza el total previsto. Con SIGINT o SIGTERM se fija como objetivo la cantidad ya aceptada.
  2. Confirmar lo admitido. Se reciben resultados válidos hasta cubrir ese objetivo.
  3. Enviar un fin por trabajador. Cada uno sale al retirar una unidad de fin y no vuelve a consumir.
  4. Recoger todos los hijos. El supervisor verifica que terminaron normalmente y cierra sus referencias.

Los mensajes de fin se emiten después de todas las confirmaciones, no solo después de que la cola de tareas parezca vacía. Una prioridad alta no sustituiría esa condición: podría adelantar el fin al trabajo.

Si se solicitó parar, las tareas previstas que nunca fueron aceptadas no se ejecutan. El resumen informa lo confirmado. El retorno es cero en una ejecución completa normal, o 128 + señal al completar una parada solicitada. Un fallo de trabajador o el agotamiento del presupuesto global provoca cancelación y retorno 1.

10. Código del formato compartido

Guarda esta cabecera junto al programa principal. Incluye el formato de 16 bytes y una consulta monotónica en milisegundos. El programa no utiliza fechas de mq_timedreceive para su supervisión: controla su presupuesto y espera señales en intervalos cortos.

tareas22.h · mensajes portables entre los procesos del proyecto
#ifndef TAREAS22_H
#define TAREAS22_H
#define _POSIX_C_SOURCE 200809L
#include <errno.h>
#include <fcntl.h>
#include <mqueue.h>
#include <signal.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <time.h>
#include <unistd.h>

#define TAM 16
#define MAX_TAREAS 1000
#define MAX_HIJOS 8
#define TAREA 1
#define FIN 2
#define RESULTADO 3

static inline void poner(unsigned char *p, uint32_t n)
{
    p[0] = (unsigned char)(n >> 24); p[1] = (unsigned char)(n >> 16);
    p[2] = (unsigned char)(n >> 8);  p[3] = (unsigned char)n;
}

static inline uint32_t obtener(const unsigned char *p)
{
    return ((uint32_t)p[0] << 24) | ((uint32_t)p[1] << 16) |
           ((uint32_t)p[2] << 8) | p[3];
}

static inline void mensaje(unsigned char *p, unsigned clase, uint32_t id,
                            uint32_t valor, uint32_t trabajador)
{
    memset(p, 0, TAM); p[0] = 1; p[1] = (unsigned char)clase;
    poner(p + 4, id); poner(p + 8, valor); poner(p + 12, trabajador);
}

static inline int formato(const unsigned char *p, ssize_t n)
{
    return n == TAM && p[0] == 1 && p[2] == 0 && p[3] == 0;
}

static inline int64_t ahora(void)
{
    struct timespec t;
    if (clock_gettime(CLOCK_MONOTONIC, &t) == -1) return -1;
    return (int64_t)t.tv_sec * 1000 + t.tv_nsec / 1000000;
}
#endif

11. Código del supervisor y los trabajadores

El supervisor crea dos nombres exclusivos, prepara las cuatro aperturas y retira ambos nombres antes de fork. Solo los procesos del proyecto utilizarán esas referencias; no hay clientes externos que necesiten localizar las colas después.

El estado armada representa un registro que todavía no se ha atendido como consumido. Solo una notificación real con código SI_MESGQ lo cambia. El supervisor registra antes de drenar y utiliza waitpid con WNOHANG para detectar fallos sin dejar de atender las colas.

reparto_cola.c · producción acotada, resultados y parada por mensajes
#include "tareas22.h"

struct hijo { pid_t pid; int recogido; };

static int numero(const char *s, int minimo, int maximo, int *salida)
{
    if (*s == '\0') return -1;
    for (const char *p = s; *p; ++p) if (*p < '0' || *p > '9') return -1;
    errno = 0;
    char *fin;
    long n = strtol(s, &fin, 10);
    if (errno == ERANGE || *fin || n < minimo || n > maximo) return -1;
    *salida = (int)n;
    return 0;
}

static mqd_t crear(char nombre[96], const char *etiqueta, int modo)
{
    struct mq_attr a = {.mq_maxmsg = 4, .mq_msgsize = TAM};
    mqd_t q = (mqd_t)-1;
    for (int i = 0; i < 100; ++i) {
        snprintf(nombre, 96, "/reparto22_%ld_%s_%d", (long)getpid(), etiqueta, i);
        q = mq_open(nombre, O_CREAT | O_EXCL | modo | O_NONBLOCK, 0600, &a);
        if (q != (mqd_t)-1 || errno != EEXIST) break;
    }
    return q;
}

static int trabajar(mqd_t tareas, mqd_t resultados, unsigned indice, int demora)
{
    unsigned char p[TAM], r[TAM];
    for (;;) {
        ssize_t n;
        do { n = mq_receive(tareas, (char *)p, TAM, NULL); }
        while (n == -1 && errno == EINTR);
        if (!formato(p, n)) return 1;
        uint32_t id = obtener(p + 4), valor = obtener(p + 8);
        if (p[1] == FIN)
            return id == 0 && valor == 0 && obtener(p + 12) == 0 ? 0 : 1;
        if (p[1] != TAREA || id == 0 || id > MAX_TAREAS || valor != id ||
            obtener(p + 12) != 0) return 1;
        struct timespec resto = {0, (long)demora * 1000000L};
        while (nanosleep(&resto, &resto) == -1)
            if (errno != EINTR) return 1;
        mensaje(r, RESULTADO, id, valor * valor, indice);
        int envio;
        do { envio = mq_send(resultados, (const char *)r, TAM, 0); }
        while (envio == -1 && errno == EINTR);
        if (envio == -1) return 1;
    }
}

static void atender(int senal, const siginfo_t *info, int *armada,
                     int *solicitud, int *objetivo, int enviadas)
{
    if (senal == SIGRTMIN && info->si_code == SI_MESGQ) *armada = 0;
    if ((senal == SIGINT || senal == SIGTERM) && !*solicitud) {
        *solicitud = senal;
        *objetivo = enviadas;
    }
    /* SIGCHLD se traduce en consultas waitpid dentro del bucle. */
}

int main(int argc, char *argv[])
{
    int total = 24, cantidad = 3, demora = 20;
    if (argc != 1 && (argc != 4 ||
        numero(argv[1], 1, MAX_TAREAS, &total) == -1 ||
        numero(argv[2], 1, MAX_HIJOS, &cantidad) == -1 ||
        numero(argv[3], 0, 50, &demora) == -1)) {
        fprintf(stderr, "Uso: %s [tareas:1..1000 trabajadores:1..8 demora_ms:0..50]\n", argv[0]);
        return 2;
    }
    sigset_t conjunto;
    struct sigaction accion = {0};
    accion.sa_handler = SIG_DFL;
    if (sigemptyset(&conjunto) == -1 || sigemptyset(&accion.sa_mask) == -1)
        return 1;
    int senales[] = {SIGRTMIN, SIGCHLD, SIGINT, SIGTERM};
    for (size_t i = 0; i < sizeof senales / sizeof senales[0]; ++i) {
        if (sigaddset(&conjunto, senales[i]) == -1 ||
            sigaction(senales[i], &accion, NULL) == -1) return 1;
    }
    if (sigprocmask(SIG_BLOCK, &conjunto, NULL) == -1) return 1;
    accion.sa_handler = SIG_IGN;
    if (sigaction(SIGPIPE, &accion, NULL) == -1) return 1;

    char nombre_t[96], nombre_r[96];
    mqd_t tp = (mqd_t)-1, rp = (mqd_t)-1, th = (mqd_t)-1, rh = (mqd_t)-1;
    int nombrada_t = 0, nombrada_r = 0, creados = 0;
    int correcto = 0, solicitud = 0, resultado = 1;
    struct hijo hijos[MAX_HIJOS] = {0};
    tp = crear(nombre_t, "t", O_WRONLY);
    if (tp == (mqd_t)-1) { perror("crear tareas"); goto limpieza; }
    nombrada_t = 1;
    rp = crear(nombre_r, "r", O_RDONLY);
    if (rp == (mqd_t)-1) { perror("crear resultados"); goto limpieza; }
    nombrada_r = 1;
    th = mq_open(nombre_t, O_RDONLY);
    rh = mq_open(nombre_r, O_WRONLY);
    if (th == (mqd_t)-1 || rh == (mqd_t)-1) { perror("aperturas de hijos"); goto limpieza; }
    if (mq_unlink(nombre_t) == -1) { perror("unlink tareas"); goto limpieza; }
    nombrada_t = 0;
    if (mq_unlink(nombre_r) == -1) { perror("unlink resultados"); goto limpieza; }
    nombrada_r = 0;
    for (int i = 0; i < cantidad; ++i) {
        pid_t pid = fork();
        if (pid == -1) { perror("fork"); goto limpieza; }
        if (pid == 0) {
            mq_close(tp); mq_close(rp);
            int r = trabajar(th, rh, (unsigned)i + 1, demora);
            mq_close(th); mq_close(rh);
            _exit(r);
        }
        hijos[creados++].pid = pid;
    }
    mq_close(th); th = (mqd_t)-1;
    mq_close(rh); rh = (mqd_t)-1;
    if (dprintf(STDOUT_FILENO, "Inicio: %d tareas, %d trabajadores\n", total, cantidad) < 0)
        goto limpieza;
    struct sigevent evento = {0};
    evento.sigev_notify = SIGEV_SIGNAL;
    evento.sigev_signo = SIGRTMIN;
    int armada = 0, enviadas = 0, confirmadas = 0, fines = 0, recogidos = 0;
    int objetivo = total;
    unsigned char vistas[MAX_TAREAS + 1] = {0};
    int64_t inicio = ahora();
    if (inicio == -1) { perror("reloj"); goto limpieza; }
    int64_t limite = inicio + 60000;
    while (recogidos < cantidad) {
        int64_t t = ahora();
        if (t == -1 || t >= limite) {
            if (t != -1) errno = ETIMEDOUT;
            perror("presupuesto de supervision"); goto limpieza;
        }
        siginfo_t info;
        struct timespec cero = {0, 0};
        for (;;) {
            int s = sigtimedwait(&conjunto, &info, &cero);
            if (s >= 0) { atender(s, &info, &armada, &solicitud, &objetivo, enviadas); continue; }
            if (errno == EINTR) continue;
            if (errno == EAGAIN) break;
            perror("senales pendientes"); goto limpieza;
        }
        if (!armada) {
            if (mq_notify(rp, &evento) == -1) { perror("mq_notify"); goto limpieza; }
            armada = 1; /* Registrar antes de drenar. */
        }
        int progreso = 0;
        for (;;) {
            unsigned char r[TAM];
            ssize_t n = mq_receive(rp, (char *)r, TAM, NULL);
            if (n == -1) {
                if (errno == EINTR) continue;
                if (errno == EAGAIN) break;
                perror("recibir resultado"); goto limpieza;
            }
            if (!formato(r, n) || r[1] != RESULTADO) {
                fprintf(stderr, "Formato de resultado invalido\n"); goto limpieza;
            }
            uint32_t id = obtener(r + 4), valor = obtener(r + 8), quien = obtener(r + 12);
            if (id == 0 || id > (uint32_t)enviadas || vistas[id] ||
                valor != id * id || quien == 0 || quien > (uint32_t)cantidad) {
                fprintf(stderr, "Resultado ajeno, incorrecto o duplicado\n"); goto limpieza;
            }
            vistas[id] = 1; ++confirmadas; progreso = 1;
            if (dprintf(STDOUT_FILENO, "Tarea %u -> %u (trabajador %u)\n",
                        (unsigned)id, (unsigned)valor, (unsigned)quien) < 0)
                goto limpieza;
        }
        while (enviadas < objetivo) {
            unsigned char p[TAM];
            mensaje(p, TAREA, (uint32_t)enviadas + 1, (uint32_t)enviadas + 1, 0);
            if (mq_send(tp, (const char *)p, TAM, 0) == -1) {
                if (errno == EINTR) continue;
                if (errno == EAGAIN) break;
                perror("enviar tarea"); goto limpieza;
            }
            ++enviadas; progreso = 1;
        }
        int finalizando = enviadas == objetivo && confirmadas == objetivo;
        if (finalizando) {
            while (fines < cantidad) {
                unsigned char p[TAM]; mensaje(p, FIN, 0, 0, 0);
                if (mq_send(tp, (const char *)p, TAM, 0) == -1) {
                    if (errno == EINTR) continue;
                    if (errno == EAGAIN) break;
                    perror("enviar fin"); goto limpieza;
                }
                ++fines; progreso = 1;
            }
        }
        for (int i = 0; i < creados; ++i) {
            if (hijos[i].recogido) continue;
            int estado;
            pid_t r = waitpid(hijos[i].pid, &estado, WNOHANG);
            if (r == -1) {
                if (errno == EINTR) continue;
                perror("waitpid"); goto limpieza;
            }
            if (r == 0) continue;
            hijos[i].recogido = 1; ++recogidos; progreso = 1;
            if (!finalizando || !WIFEXITED(estado) || WEXITSTATUS(estado) != 0) {
                fprintf(stderr, "Trabajador %d termino antes de completar el protocolo\n", i + 1);
                goto limpieza;
            }
        }
        if (recogidos == cantidad) break;
        if (!progreso) {
            struct timespec breve = {0, 100000000L};
            int s = sigtimedwait(&conjunto, &info, &breve);
            if (s >= 0) atender(s, &info, &armada, &solicitud, &objetivo, enviadas);
            else if (errno != EAGAIN && errno != EINTR) { perror("esperar evento"); goto limpieza; }
        }
    }
    if (enviadas != objetivo || confirmadas != objetivo || fines != cantidad) {
        fprintf(stderr, "Contadores finales incompatibles\n"); goto limpieza;
    }
    if (dprintf(STDOUT_FILENO, "Completadas: %d. Trabajadores recogidos: %d.\n",
                confirmadas, recogidos) < 0) goto limpieza;
    correcto = 1;
    resultado = solicitud ? 128 + solicitud : 0;
limpieza:
    if (rp != (mqd_t)-1 && mq_notify(rp, NULL) == -1) {
        perror("cancelar registro"); resultado = 1;
    }
    if (!correcto) {
        for (int i = 0; i < creados; ++i)
            if (!hijos[i].recogido && kill(hijos[i].pid, SIGKILL) == -1 && errno != ESRCH)
                perror("cancelar hijo");
        for (int i = 0; i < creados; ++i) {
            if (hijos[i].recogido) continue;
            int estado;
            while (waitpid(hijos[i].pid, &estado, 0) == -1) {
                if (errno == EINTR) continue;
                perror("recoger hijo"); break;
            }
        }
    }
    if (nombrada_t && mq_unlink(nombre_t) == -1) { perror("unlink tareas"); resultado = 1; }
    if (nombrada_r && mq_unlink(nombre_r) == -1) { perror("unlink resultados"); resultado = 1; }
    mqd_t referencias[] = {tp, rp, th, rh};
    for (size_t i = 0; i < sizeof referencias / sizeof referencias[0]; ++i)
        if (referencias[i] != (mqd_t)-1 && mq_close(referencias[i]) == -1) {
            perror("mq_close"); resultado = 1;
        }
    return resultado;
}

El supervisor no utiliza un receptor bloqueante de resultados que compita con mq_notify. Espera señales cuando no hay progreso inmediato, con una revisión periódica adicional de hijos y presupuesto. El orden de finalización no se deduce del orden de envío.

El escritor de tareas se mantiene no bloqueante durante toda la supervisión. Los trabajadores usan sus aperturas separadas y bloqueantes, sin alterar los flags del supervisor. El registro de aviso pertenece únicamente al proceso padre.

12. Compilar y observar el reparto

Bash en Linux o WSL · ambos archivos en el mismo directorio
$ gcc -std=c17 -Wall -Wextra -Wpedantic reparto_cola.c -o reparto_cola -lrt
$ ./reparto_cola 12 3 20
Inicio: 12 tareas, 3 trabajadores
Tarea 1 -> 1 (trabajador 1)
Tarea 3 -> 9 (trabajador 3)
Tarea 2 -> 4 (trabajador 2)
...
Completadas: 12. Trabajadores recogidos: 3.
$ echo $?
0

Las líneas de tareas son ilustrativas: el trabajador asignado y el orden de llegada pueden variar. Lo que debe mantenerse es una confirmación de cada identificador 1..12, su cuadrado correcto y la recolección de tres hijos.

Sin argumentos se ejecutan 24 tareas, tres trabajadores y 20 ms de demora por tarea. La demora representa coste simulado; no es una espera para que otro proceso «esté listo».

13. Probar carga, interrupción y fallos

Bash · más tareas que plazas y más trabajadores que tareas
$ ./reparto_cola 1000 8 0 > resultados22.txt
$ tail -n 1 resultados22.txt
Completadas: 1000. Trabajadores recogidos: 8.
$ ./reparto_cola 1 8 0
... una tarea confirmada; los ocho trabajadores reciben fin y son recogidos ...

La segunda prueba comprueba que un trabajador sin tareas también termina. Verifica además identificadores únicos y valores, no solo el número total de líneas.

Bash · solicitar cierre de producción durante el trabajo
$ ./reparto_cola 1000 3 50 > parada22.txt &
$ supervisor=$!
$ kill -TERM "$supervisor"
$ wait "$supervisor"
$ echo $?
143
$ tail -n 1 parada22.txt
Completadas: ... . Trabajadores recogidos: 3.

Para observar la parada ordenada, envía la señal después de ver «Inicio» o de comprobar que el supervisor ya creó sus hijos. Una señal enviada antes de que el programa establezca su política puede terminarlo con la acción previa. La cantidad confirmada depende de cuántas tareas se aceptaron antes de atender la solicitud.

En una terminal también puedes usar Ctrl+C una vez que comenzó el trabajo. Los hijos conservan bloqueada la señal, el padre la recibe síncronamente y completa lo admitido. Para simular un trabajador caído, identifica un hijo propio y envíale SIGKILL: el supervisor debe fallar, cancelar a los restantes y recogerlos.

Una variante de prueba puede simular que el tercer fork devuelve EAGAIN. Esa ruta debe limpiar los hijos ya creados. No hace falta agotar los procesos del sistema para comprobarla.

14. Responsabilidad sobre hijos y colas

RecursoPreparaciónLimpieza
Nombres temporales.O_CREAT | O_EXCL evita adoptar colas preexistentes.Se retiran antes de fork; si falla antes, se retiran solo los creados.
Aperturas de trabajadores.Se crean mientras existen los nombres.Los hijos las cierran; el padre cierra sus copias tras lanzar.
Aperturas del supervisor.Productor de tareas y receptor de resultados no bloqueantes.Se cierra cada referencia al terminar.
Registro mq_notify.Solo el padre registra sobre resultados.Se cancela el registro que pudiera seguir activo antes de cerrar.
Procesos hijos.Se conserva su PID y si ya fue recogido.Se verifica cada terminación; ante fallo se cancelan solo hijos aún no recogidos.

La distinción de hijos recogidos evita enviar señales a un PID que el sistema ya pudiera reutilizar. Primero se cancelan todos los pendientes y después se realizan las esperas de limpieza. El contrato de recolección se describe en wait(2).

Los nombres desaparecen pronto, pero los objetos siguen vivos hasta cerrar sus últimas referencias. Una caída del supervisor por SIGKILL puede dejar trabajadores vivos, porque ningún proceso ejecuta su limpieza después de esa señal. La robustez frente a esa situación requeriría otra política de supervisión; no se promete aquí.

15. Explorar la carrera de notificación

El modelo comienza con un aviso ya atendido y un resultado A pendiente. Compara drenar antes de registrar con registrar antes de drenar. Inserta una llegada B en el intervalo que quieras y observa si queda un aviso pendiente o contenido sin despertar.

Resultados en colaA

Registro activoNo; el aviso anterior fue consumido

Señal pendienteNo

SupervisorPor iniciar un ciclo

Avanza un paso y prueba insertar una llegada antes del segundo.

Para reproducir la carrera, elige el orden inseguro, drena A, haz llegar B y registra. Al esperar puede quedar B sin una señal que despierte. En el orden correcto, la llegada queda cubierta por el registro o es consumida por el drenado posterior.

16. Diagnóstico y límites de recuperación

Bash · seguir supervisor, trabajadores y notificaciones
$ strace -f -o reparto22.log ./reparto_cola 12 3 20
$ less reparto22.log

Localiza creación y desvinculación de dos colas, fork, registro mq_notify, recepción de señales, drenados no bloqueantes y waitpid. La biblioteca puede mostrar mq_timedreceive, mq_timedsend, rt_sigtimedwait, clone o wait4 como llamadas subyacentes.

SíntomaQué comprobar
El programa se detiene con ambas colas llenas.El supervisor pudo enviar tareas bloqueando antes de atender resultados.
mq_notify devuelve EBUSY.Queda un registro activo; no se ha consumido su aviso o hay otro registrador.
Quedan resultados sin señal.Se registró después de drenar, o se esperaba un aviso por mensaje.
No hay aviso aunque un trabajador produjo.Otro receptor pudo recibir directamente, o la cola ya tenía contenido.
Una cola vacía se interpreta como trabajo terminado.Falta contar tareas retiradas pero todavía no confirmadas.
Un trabajador queda esperando al final.Faltó un mensaje de fin por trabajador vivo.
El total coincide, pero falta un identificador.Puede haber duplicados; hay que verificar identificadores y no solo sumar resultados.

El proyecto detecta el fallo de un trabajador y cancela; no reintenta su tarea automáticamente. Si el trabajador cayó después de retirar y antes de confirmar, la cola de tareas no repone esa unidad. La recuperación necesita un registro de trabajo en curso, plazos por tarea y una política de idempotencia.

La salida estándar puede ser lenta y no está incluida como recurso no bloqueante del bucle. El presupuesto global se comprueba entre iteraciones, no interrumpe por sí mismo una escritura de diagnóstico bloqueada. El ejemplo se usa con una terminal o archivo que progresa.

Las características de persistencia y las referencias de colas POSIX se resumen en mq_overview(7). No hay almacenamiento durable de tareas ni garantía de recuperación tras caída del sistema.

17. Resumen

18. Preguntas de repaso y ampliaciones

Responde antes de desplegar las explicaciones.

1. ¿Todos los trabajadores reciben una copia de cada tarea?

No. Compiten por la cola y cada recepción correcta retira una unidad para un trabajador.

2. ¿Por qué se usa otra cola para resultados?

Para separar tareas pendientes de confirmaciones y permitir que el supervisor valide lo procesado sin competir con los trabajadores por el mismo tipo de recepción.

3. ¿Por qué no se envían todas las tareas bloqueando?

Porque los trabajadores pueden llenar resultados y esperar al supervisor mientras él espera espacio en tareas. El bucle no bloqueante permite atender ambas direcciones.

4. ¿mq_notify genera una señal por resultado?

No. Avisa de una llegada a cola vacía con un registro activo. El registro es de un solo uso y la señal no retira el contenido.

5. ¿Por qué se rearma antes de drenar?

Para cubrir las llegadas durante o después del drenado y evitar un intervalo con contenido nuevo y sin registro que lo observe.

6. ¿Por qué el supervisor no recibe resultados con bloqueo?

Porque un receptor directamente bloqueado puede recibir el mensaje sin el aviso esperado y porque el supervisor debe seguir atendiendo producción, señales e hijos.

7. ¿Una SIGCHLD representa exactamente un hijo terminado?

No. El supervisor consulta todos los PID pendientes con waitpid y no cuenta señales como si fueran procesos.

8. ¿Por qué los trabajadores mantienen bloqueado Ctrl+C?

Para que el supervisor reciba la solicitud, cierre la producción y permita terminar tareas aceptadas antes de enviar los mensajes de fin.

9. ¿Cuándo se envían los mensajes de fin?

Después de recibir resultados válidos de todas las tareas admitidas. Se envía uno por trabajador, cada uno termina al retirar el suyo.

10. ¿Por qué no basta un contador de resultados?

Porque un duplicado podría compensar numéricamente una tarea ausente. El registro por identificador permite detectarlo.

11. ¿Por qué se retiran los nombres antes de fork?

Porque ya se abrieron todas las referencias necesarias y ningún cliente externo debe conectarse. Los objetos permanecen mientras existan esas referencias.

12. ¿Qué pasa si cae un trabajador después de retirar una tarea?

El supervisor detecta su terminación y cancela la ejecución. La tarea no reaparece automáticamente; recuperar trabajo exigiría seguimiento y reintentos explícitos.

Para practicar y ampliar

  1. Ejecuta con uno y con ocho trabajadores, verificando cada identificador y cuadrado. No exijas un reparto uniforme.
  2. Reduce las plazas de ambas colas a uno y prueba más tareas que su capacidad. Explica por qué debe seguir progresando.
  3. Ejecuta con una tarea y ocho trabajadores. Comprueba que también terminan los que no procesaron tareas.
  4. Solicita SIGTERM después del inicio y verifica que el resumen cubre todas las tareas aceptadas antes del cierre de producción.
  5. En una prueba propia, termina un trabajador con SIGKILL. Comprueba que se recogen los restantes y no quedan nombres temporales.
  6. Simula un fallo de fork intermedio y revisa la ruta de limpieza.
  7. Usa el explorador para insertar una llegada entre drenado y registro. Compara los dos órdenes.
  8. Añade una tarea de otro tipo y define primero el formato de su resultado y la validación correspondiente.
  9. Diseña un seguimiento de tareas en curso que permita reintentar una perdida. Incluye cómo detectar resultados duplicados y cómo evitar efectos externos repetidos.
Próximo paso

Con este proyecto termina el bloque de colas de mensajes. El tema 23 iniciará memoria compartida: crear una región con mmap, heredarla mediante fork y distinguir MAP_SHARED de MAP_PRIVATE.