1. Cuatro operaciones y dos clases de retorno
En el tema 20 aprendimos a crear, abrir y validar una cola. Aquí suponemos que el responsable ya la creó y que el nombre permanece disponible para conectar productores y consumidores.
int mq_send(mqd_t cola, const char *datos, size_t longitud,
unsigned prioridad);
ssize_t mq_receive(mqd_t cola, char *buffer, size_t capacidad,
unsigned *prioridad);
int mq_timedsend(mqd_t cola, const char *datos, size_t longitud,
unsigned prioridad, const struct timespec *limite);
ssize_t mq_timedreceive(mqd_t cola, char *buffer, size_t capacidad,
unsigned *prioridad, const struct timespec *limite);El envío retorna 0 al aceptar el mensaje completo y −1 al fallar. La recepción retorna una longitud mayor o igual a cero al retirar una unidad y −1 al fallar. En los fallos se consulta errno.
El éxito de enviar significa aceptación por el mecanismo de cola. El éxito de recibir significa que se retiró un mensaje; ninguno confirma por sí solo que una tarea haya terminado correctamente.
Las versiones con plazo mantienen el mismo contrato de contenido. Su diferencia es cómo limitan una espera que sería necesaria para progresar.
2. Enviar contenido con longitud explícita
const char texto[] = "hola";
if (mq_send(cola, texto, strlen(texto), 2) == -1) {
perror("mq_send");
}
/* Se envian cuatro bytes; el terminador NUL no pertenece al mensaje. */La longitud debe ser como máximo mq_msgsize. El núcleo no necesita que el contenido termine en NUL. Si el protocolo desea enviar ese terminador, debe incluirlo expresamente y exigirlo al receptor.
Un mensaje puede contener bytes cero y también tener longitud cero. Un retorno exitoso de mq_send no es una cantidad de bytes: no avances por un supuesto prefijo ni envíes un sufijo como si fuera write sobre un flujo.
Después de un envío exitoso puedes reutilizar el búfer del proceso. La cola conserva la unidad aceptada; no conserva un puntero que el receptor deba desreferenciar. El contrato de envío está en mq_send(3).
3. Preparar el búfer de recepción
Consulta mq_msgsize y reserva al menos esa cantidad de bytes. mq_receive no acepta un búfer menor aunque el próximo mensaje concreto pudiera caber en él. Si el tamaño es insuficiente, falla con EMSGSIZE sin retirar esa unidad.
unsigned prioridad;
ssize_t n = mq_receive(cola, buffer, capacidad, &prioridad);
if (n == -1) {
perror("mq_receive");
} else {
fwrite(buffer, 1, (size_t)n, stdout);
}No utilices printf con %s sobre un resultado que no sabes si termina en NUL. Si deseas construir una cadena local, reserva un byte adicional y colócalo después de los n bytes recibidos, sin incluirlo como capacidad extra del protocolo.
El valor cero es un mensaje vacío retirado correctamente, no EOF. Una cola sin mensajes espera o informa EAGAIN, según el estado de la apertura. La recepción se describe en mq_receive(3).
4. Ordenar por prioridad sin prometer equidad
Entre los mensajes pendientes se selecciona primero la prioridad numérica mayor. A igual prioridad, se conserva el orden de entrada. Para una cola de tareas estrictamente FIFO entre todas las solicitudes, utiliza una prioridad uniforme.
Consulta el límite con sysconf(_SC_MQ_PRIO_MAX): son válidas prioridades no negativas menores que ese valor. No fijes en el protocolo el máximo observado en un único equipo. Los ejemplos utilizan números pequeños.
Si un consumidor ya retiró normal-A antes de llegar urgente, el mensaje nuevo no puede recuperarlo ni interrumpir su procesamiento. La prioridad de cola tampoco cambia la prioridad del planificador de CPU.
Una llegada sostenida de prioridad alta puede postergar tareas de prioridad baja. Si necesitas equidad, define cuotas, envejecimiento u otra política sobre los productores y consumidores.
5. Bloqueo y modo no bloqueante
| Estado | Apertura bloqueante | Apertura con O_NONBLOCK |
|---|---|---|
| Enviar con espacio. | Puede completar. | Puede completar. |
| Enviar con cola llena. | Puede esperar a que se retire un mensaje. | Falla con EAGAIN. |
| Recibir con contenido. | Retira la unidad seleccionada. | Retira la unidad seleccionada. |
| Recibir con cola vacía. | Puede esperar un mensaje. | Falla con EAGAIN. |
Las funciones con plazo no neutralizan O_NONBLOCK. Si la apertura conserva ese flag, la falta de progreso produce EAGAIN y no se espera hasta la fecha límite. Para demostrar una espera temporal, la herramienta abre sin ese flag en el modo plazo.
Recuerda que el estado de espera pertenece a la descripción de apertura. Un cambio mediante una referencia heredada puede afectar a otros usuarios de esa misma apertura, como se comprobó en el tema 20.
6. Clasificar los errores antes de reintentar
| Error | Significado habitual | Respuesta adecuada |
|---|---|---|
| EAGAIN. | No puede progresar ahora en modo no bloqueante. | Conservar la solicitud o esperar un evento; evitar un bucle que consuma CPU. |
| ETIMEDOUT. | Venció la espera temporal necesaria. | Aplicar la política de vencimiento de esa operación. |
| EINTR. | La espera fue interrumpida por una señal. | Decidir si cancelar o reintentar sin cambiar el plazo original. |
| EMSGSIZE. | Envío demasiado grande o capacidad receptora inferior a mq_msgsize. | Corregir el tamaño; no esperar a que cambie la ocupación. |
| EINVAL. | Prioridad fuera de rango u otros argumentos temporales inválidos. | Validar el contrato y la representación de timespec. |
| EBADF. | Referencia inválida o acceso incompatible con enviar/recibir. | Revisar la apertura y su vida útil. |
No confíes en el errno de una llamada que tuvo éxito: puede conservar un valor anterior. Si necesitas clasificar un fallo después de imprimir o cerrar recursos, guarda su causa antes.
Para una solicitud válida que no se pudo encolar por EAGAIN, EINTR o ETIMEDOUT, no existe un prefijo pendiente aceptado por esa llamada. Un envío anterior que ya retornó cero es otra operación y no debe repetirse sin una política de duplicados.
7. Construir una fecha límite absoluta
mq_timedsend y mq_timedreceive reciben una fecha absoluta basada en CLOCK_REALTIME, no una cantidad relativa de milisegundos. Un timespec con dos segundos no significa «espera dos segundos»: representa un instante cercano al inicio de la época.
struct timespec limite;
if (clock_gettime(CLOCK_REALTIME, &limite) == -1) {
perror("clock_gettime");
/* No utilizar un limite sin inicializar. */
}
limite.tv_sec += 1;
limite.tv_nsec += 500000000L;
if (limite.tv_nsec >= 1000000000L) {
++limite.tv_sec;
limite.tv_nsec -= 1000000000L;
}tv_nsec debe quedar entre cero y 999999999. La construcción y la llamada tienen que seguir caminos de error separados: el fragmento supone que solo se continúa si se obtuvo el reloj.
Una fecha ya vencida no fuerza el fallo cuando la operación puede completarse inmediatamente. Si hay mensaje disponible, una recepción temporal puede tener éxito; si hay espacio, también un envío. El laboratorio lo verificará con una fecha válida del pasado.
8. Plazo de calendario y presupuesto de duración
El CLOCK_MONOTONIC del tema 18 no se pasa directamente como fecha a estas funciones. El reloj que interpreta la API temporal de colas es CLOCK_REALTIME. Mezclar épocas produce plazos erróneos aunque los campos de timespec parezcan válidos.
CLOCK_REALTIME puede ajustarse. Si tu requisito es limitar una duración independientemente de cambios del reloj de calendario, una única fecha real no ofrece la misma propiedad que un presupuesto monotónico.
En un diseño más exigente puedes conservar un límite monotónico y utilizar esperas cortas controladas, recalculando lo que queda. La integración de descriptores de cola con poll es una posibilidad específica de Linux; no es una propiedad portable de mqd_t. Este tema utiliza directamente la API temporal estándar y declara su reloj.
Los relojes y sus diferencias se documentan en clock_gettime(2). Los milisegundos de la herramienta se convierten una sola vez en una fecha real por operación.
9. Reintentar EINTR sin renovar el plazo
/* Calcular limite una sola vez antes de este bucle. */
ssize_t n;
do {
n = mq_timedreceive(cola, buffer, capacidad, &prioridad, &limite);
} while (n == -1 && errno == EINTR);Si calculas «ahora más dos segundos» en cada reintento, cada señal renueva el presupuesto. Una secuencia de interrupciones podría alargar la espera mucho más de lo solicitado.
Reintentar no es la única política posible. Si un manejador solicita terminar mediante un flag, compruébalo y abandona según el protocolo. Los programas siguientes no instalan manejadores de parada: conservan el comportamiento habitual de las señales del entorno y reintentan EINTR si una llamada retorna esa causa.
10. Programa: enviar y recibir desde la terminal
La herramienta usa una cola existente, creada con mq_admin del tema 20. No crea ni desvincula nombres. Cada invocación hace una sola operación y cierra su propia referencia.
Los modos son bloquear, ahora y plazo. Solo plazo exige una duración de 1 a 60000 ms. La recepción reserva mq_msgsize, con un límite local de un MiB para evitar reservas desmesuradas por una cola de configuración inesperada. Ese límite es una decisión del programa.
#define _POSIX_C_SOURCE 200809L
#include <errno.h>
#include <fcntl.h>
#include <limits.h>
#include <mqueue.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <unistd.h>
static int numero(const char *s, unsigned long *valor)
{
if (*s == '\0') 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 == ERANGE || *fin != '\0') return -1;
*valor = n;
return 0;
}
static int nombre_valido(const char *s)
{
size_t n = strlen(s);
if (n < 2 || n > 128 || s[0] != '/') return 0;
for (size_t i = 1; 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 == '-' || c == '.'))
return 0;
}
return 1;
}
static int fecha(struct timespec *t, unsigned long ms)
{
if (clock_gettime(CLOCK_REALTIME, t) == -1) return -1;
t->tv_sec += (time_t)(ms / 1000);
t->tv_nsec += (long)(ms % 1000) * 1000000L;
if (t->tv_nsec >= 1000000000L) {
++t->tv_sec;
t->tv_nsec -= 1000000000L;
}
return 0;
}
static int informar_error(const char *operacion)
{
int causa = errno;
perror(operacion);
return causa == EAGAIN ? 3 : causa == ETIMEDOUT ? 4 : 1;
}
int main(int argc, char *argv[])
{
if (argc < 4) goto uso;
int envio = strcmp(argv[1], "enviar") == 0;
if (!envio && strcmp(argv[1], "recibir") != 0) goto uso;
int indice_modo = envio ? 5 : 3;
if (argc <= indice_modo || !nombre_valido(argv[2])) goto uso;
const char *modo = argv[indice_modo];
int temporal = strcmp(modo, "plazo") == 0;
int inmediato = strcmp(modo, "ahora") == 0;
if (!temporal && !inmediato && strcmp(modo, "bloquear") != 0) goto uso;
if (argc != indice_modo + 1 + temporal) goto uso;
unsigned long ms = 0, valor_prioridad = 0;
if (temporal && (numero(argv[indice_modo + 1], &ms) == -1 ||
ms == 0 || ms > 60000)) goto uso;
if (envio) {
if (numero(argv[3], &valor_prioridad) == -1 || valor_prioridad > UINT_MAX)
goto uso;
errno = 0;
long maximo = sysconf(_SC_MQ_PRIO_MAX);
if (maximo == -1) {
if (errno == 0) errno = ENOTSUP;
return informar_error("limite de prioridad");
}
if (valor_prioridad >= (unsigned long)maximo) goto uso;
}
mqd_t cola = mq_open(argv[2], (envio ? O_WRONLY : O_RDONLY) |
(inmediato ? O_NONBLOCK : 0));
if (cola == (mqd_t)-1) return informar_error("mq_open");
int resultado = 0;
char *buffer = NULL;
struct mq_attr a;
if (mq_getattr(cola, &a) == -1) {
resultado = informar_error("mq_getattr"); goto limpieza;
}
if (a.mq_msgsize <= 0) {
errno = EINVAL; resultado = informar_error("atributos"); goto limpieza;
}
size_t cantidad;
if (envio) {
cantidad = strlen(argv[4]);
if ((uintmax_t)cantidad > (uintmax_t)a.mq_msgsize) {
errno = EMSGSIZE; resultado = informar_error("texto excesivo");
goto limpieza;
}
} else {
if ((uintmax_t)a.mq_msgsize > 1048576U) {
fprintf(stderr, "mq_msgsize supera el limite local de un MiB\n");
resultado = 1; goto limpieza;
}
cantidad = (size_t)a.mq_msgsize;
buffer = malloc(cantidad);
if (buffer == NULL) { resultado = informar_error("malloc"); goto limpieza; }
}
struct timespec limite;
if (temporal && fecha(&limite, ms) == -1) {
resultado = informar_error("clock_gettime"); goto limpieza;
}
if (envio) {
int r;
do {
r = temporal ?
mq_timedsend(cola, argv[4], cantidad, (unsigned)valor_prioridad, &limite) :
mq_send(cola, argv[4], cantidad, (unsigned)valor_prioridad);
} while (r == -1 && errno == EINTR);
if (r == -1) resultado = informar_error("enviar");
else if (puts("Mensaje aceptado por la cola") == EOF || fflush(stdout) == EOF)
resultado = informar_error("mostrar envio");
} else {
unsigned prioridad;
ssize_t n;
do {
n = temporal ? mq_timedreceive(cola, buffer, cantidad, &prioridad, &limite) :
mq_receive(cola, buffer, cantidad, &prioridad);
} while (n == -1 && errno == EINTR);
if (n == -1) resultado = informar_error("recibir");
else if (printf("prioridad=%u bytes=%zd contenido=", prioridad, n) < 0 ||
fwrite(buffer, 1, (size_t)n, stdout) != (size_t)n ||
putchar('\n') == EOF || fflush(stdout) == EOF)
resultado = informar_error("mostrar recepcion");
}
limpieza:
free(buffer);
if (mq_close(cola) == -1) resultado = informar_error("mq_close");
return resultado;
uso:
fprintf(stderr, "Uso: %s enviar /nombre prioridad texto modo [ms]\n"
" %s recibir /nombre modo [ms]\n"
"Modos: bloquear | ahora | plazo (requiere ms: 1..60000)\n",
argv[0], argv[0]);
return 2;
}La herramienta devuelve 0 si completa su operación y presentación, 1 por un fallo general, 2 por argumentos inválidos, 3 por EAGAIN y 4 por ETIMEDOUT. Son convenciones del programa, no valores que retornen directamente las funciones mq_*.
La fecha se calcula después de abrir y preparar el búfer. Por tanto, el parámetro ms limita la espera de esa operación de cola; no incluye todo el proceso, la conexión inicial ni una salida stdout lenta.
11. Probar prioridades entre procesos independientes
$ gcc -std=c17 -Wall -Wextra -Wpedantic mq_io.c -o mq_io -lrt
$ nombre="/curso21_${UID}_$$"
$ ./mq_admin crear "$nombre" 3 64
$ ./mq_io enviar "$nombre" 2 'normal-A' ahora
Mensaje aceptado por la cola
$ ./mq_io enviar "$nombre" 9 'urgente' ahora
$ ./mq_io enviar "$nombre" 2 'normal-B' ahora
$ ./mq_io recibir "$nombre" ahora
prioridad=9 bytes=7 contenido=urgente
$ ./mq_io recibir "$nombre" ahora
prioridad=2 bytes=8 contenido=normal-A
$ ./mq_io recibir "$nombre" ahora
prioridad=2 bytes=8 contenido=normal-BLos tres envíos deben completarse antes de iniciar las recepciones de esta prueba. Si el consumidor ya estuviera esperando, podría retirar normal-A antes de que llegara urgente: la prioridad no reordena algo que ya salió de la cola.
Cada orden es un proceso distinto y abre su propia referencia. El emisor no necesita un receptor activo; la cola conserva el contenido aceptado dentro de su capacidad.
12. Probar vacío, saturación y despertar
$ ./mq_io recibir "$nombre" ahora
recibir: Resource temporarily unavailable
$ echo $?
3
$ ./mq_io recibir "$nombre" plazo 500
recibir: Connection timed out
$ echo $?
4Los textos dependen del idioma. Las condiciones importantes son EAGAIN y ETIMEDOUT, respectivamente. El tiempo observado puede incluir retrasos de planificación; no uses la duración de una orden como una medida exacta del reloj del núcleo.
$ for texto in uno dos tres; do ./mq_io enviar "$nombre" 1 "$texto" ahora; done
$ ./mq_io enviar "$nombre" 1 'cuatro' ahora
enviar: Resource temporarily unavailable
$ ./mq_io enviar "$nombre" 1 'cuatro' plazo 500
enviar: Connection timed outNinguna de esas dos llamadas encoló cuatro. Para mostrar el despertar, inicia un nuevo envío con plazo en segundo plano y retira una unidad desde el primer plano:
$ ./mq_io enviar "$nombre" 1 'cuatro' plazo 5000 &
$ emisor=$!
$ ./mq_io recibir "$nombre" ahora
prioridad=1 bytes=3 contenido=uno
$ wait "$emisor"
... el emisor termina con éxito al tener espacio ...
$ ./mq_io recibir "$nombre" ahora
prioridad=1 bytes=3 contenido=dos
$ ./mq_io recibir "$nombre" ahora
prioridad=1 bytes=4 contenido=tres
$ ./mq_io recibir "$nombre" ahora
prioridad=1 bytes=6 contenido=cuatroEl orden en pantalla del diagnóstico de aceptación del emisor puede variar. Su estado y la recepción final muestran el resultado. Al terminar todos los usos, retira la cola propia con ./mq_admin retirar "$nombre".
13. Laboratorio: plazo vencido y mensaje vacío
El siguiente programa crea una cola temporal de una unidad de hasta ocho bytes, la desvincula y controla todos sus estados desde un proceso. No requiere la cola de las pruebas anteriores ni un interlocutor externo.
Comprueba que una fecha pasada no impide completar si ya hay espacio o contenido; después fuerza ETIMEDOUT y demuestra que O_NONBLOCK produce EAGAIN en las versiones temporales. Finalmente transporta un mensaje vacío y otro con un byte cero interior.
#define _POSIX_C_SOURCE 200809L
#include <errno.h>
#include <fcntl.h>
#include <mqueue.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <time.h>
#include <unistd.h>
static int limite(struct timespec *t, long ms)
{
if (clock_gettime(CLOCK_REALTIME, t) == -1) return -1;
t->tv_sec += ms / 1000;
t->tv_nsec += (ms % 1000) * 1000000L;
if (t->tv_nsec >= 1000000000L) { ++t->tv_sec; t->tv_nsec -= 1000000000L; }
return 0;
}
static int enviar(mqd_t q, const char *p, size_t n, const struct timespec *fin)
{
int r;
do { r = mq_timedsend(q, p, n, 0, fin); }
while (r == -1 && errno == EINTR);
return r;
}
static ssize_t recibir(mqd_t q, char *p, const struct timespec *fin)
{
ssize_t n;
do { n = mq_timedreceive(q, p, 8, NULL, fin); }
while (n == -1 && errno == EINTR);
return n;
}
int main(void)
{
char nombre[96];
struct mq_attr a = {.mq_maxmsg = 1, .mq_msgsize = 8};
mqd_t q = (mqd_t)-1;
for (int intento = 0; intento < 100; ++intento) {
snprintf(nombre, sizeof nombre, "/plazos21_%ld_%d", (long)getpid(), intento);
q = mq_open(nombre, O_CREAT | O_EXCL | O_RDWR, 0600, &a);
if (q != (mqd_t)-1 || errno != EEXIST) break;
}
if (q == (mqd_t)-1) { perror("mq_open"); return 1; }
int resultado = 1, desvinculada = 0;
if (mq_unlink(nombre) == -1) { perror("mq_unlink"); goto limpieza; }
desvinculada = 1;
struct timespec pasado = {0, 0}, fin;
char buffer[8];
if (enviar(q, "OK", 2, &pasado) == -1 || recibir(q, buffer, &pasado) != 2)
goto inesperado;
puts("Plazo pasado con progreso inmediato: envio y recepcion correctos");
if (enviar(q, "X", 1, &pasado) == -1 || limite(&fin, 300) == -1)
goto inesperado;
if (enviar(q, "Y", 1, &fin) != -1 || errno != ETIMEDOUT) goto inesperado;
puts("Cola llena, apertura bloqueante: ETIMEDOUT al enviar");
if (recibir(q, buffer, &pasado) != 1 || limite(&fin, 300) == -1)
goto inesperado;
if (recibir(q, buffer, &fin) != -1 || errno != ETIMEDOUT) goto inesperado;
puts("Cola vacia, apertura bloqueante: ETIMEDOUT al recibir");
struct mq_attr modo = {.mq_flags = O_NONBLOCK};
if (mq_setattr(q, &modo, NULL) == -1 || limite(&fin, 5000) == -1)
goto inesperado;
if (recibir(q, buffer, &fin) != -1 || errno != EAGAIN) goto inesperado;
puts("O_NONBLOCK con plazo futuro: EAGAIN al recibir");
if (enviar(q, "Z", 1, &fin) == -1 ||
enviar(q, "W", 1, &fin) != -1 || errno != EAGAIN) goto inesperado;
puts("O_NONBLOCK con cola llena: EAGAIN al enviar");
if (recibir(q, buffer, &fin) != 1 || enviar(q, "", 0, &fin) == -1 ||
recibir(q, buffer, &fin) != 0) goto inesperado;
puts("Mensaje vacio retirado: 0 bytes, no EOF");
const char binario[] = {'A', '\0', 'B'};
if (enviar(q, binario, sizeof binario, &fin) == -1 ||
recibir(q, buffer, &fin) != 3) goto inesperado;
printf("Binario recibido: %02x %02x %02x\n", (unsigned char)buffer[0],
(unsigned char)buffer[1], (unsigned char)buffer[2]);
if (buffer[0] != 'A' || buffer[1] != '\0' || buffer[2] != 'B') goto inesperado;
resultado = 0;
goto limpieza;
inesperado:
fprintf(stderr, "Resultado distinto del esperado\n");
limpieza:
if (mq_close(q) == -1) { perror("mq_close"); resultado = 1; }
if (!desvinculada && mq_unlink(nombre) == -1) perror("mq_unlink limpieza");
return resultado;
}$ gcc -std=c17 -Wall -Wextra -Wpedantic plazos_mq.c -o plazos_mq -lrt
$ ./plazos_mq
Plazo pasado con progreso inmediato: envio y recepcion correctos
Cola llena, apertura bloqueante: ETIMEDOUT al enviar
Cola vacia, apertura bloqueante: ETIMEDOUT al recibir
O_NONBLOCK con plazo futuro: EAGAIN al recibir
O_NONBLOCK con cola llena: EAGAIN al enviar
Mensaje vacio retirado: 0 bytes, no EOF
Binario recibido: 41 00 42La fecha {0, 0} es válida y pasada en el entorno Linux actual. No debe confundirse con tv_nsec fuera de rango, que es un argumento inválido. Si una llamada no puede progresar, una fecha vencida evita iniciar una espera adicional.
14. Confirmación, cancelación y fin de trabajo
Enviar con éxito no confirma que un trabajador ya recibió. Recibir con éxito retira el mensaje antes de procesarlo. Si ese trabajador falla después, la cola no repone automáticamente la tarea.
Un timeout de una recepción significa que esa llamada no retiró un mensaje. No demuestra que no exista un productor activo ni que una solicitud enviada antes no haya sido procesada por otro participante. La confirmación de una tarea requiere una respuesta con su identificador.
Cancelar una orden de terminal después de encolar no borra el mensaje. Del mismo modo, si la herramienta retira una unidad y falla al mostrarla en stdout, esa recepción ya ocurrió. No reencoles automáticamente sin decidir cómo tratar posibles duplicados.
Las colas no producen EOF por cierre de productores. Para varios trabajadores puedes definir mensajes de parada y una fase que impida nuevas tareas, pero una parada de prioridad alta podría adelantarse al trabajo pendiente. El tema 22 integrará ese protocolo con un conjunto de trabajadores.
15. Explorar esperas y eventos
El modelo tiene tres plazas y mensajes de hasta ocho bytes. Inicia una operación local y usa al interlocutor para añadir o retirar contenido. El reloj avanza por pasos manuales; no representa segundos reales. El flag O_NONBLOCK permite comprobar su efecto incluso al seleccionar una función con plazo.
Mensajes pendientesSin mensajes
Ocupación0/3 plazas
Tiempo del modelo0
Operación localNinguna en espera
Prueba recibir con cola vacía y luego haz enviar al interlocutor.
Los parámetros de una operación se capturan al iniciarla; cambiar los controles mientras espera no modifica esa solicitud. El interlocutor utiliza el contenido y la prioridad actuales de los controles.
Prueba una recepción con plazo cero sobre una cola vacía y después sobre una con contenido. Compara el resultado con O_NONBLOCK. Para observar un envío pendiente, llena las tres plazas con el interlocutor y retira una después de iniciar el envío local.
16. Diagnosticar tamaños, modos y tiempos
$ strace -tt -o mq21.log ./mq_io recibir "$nombre" plazo 1000
$ less mq21.logEjecuta esta prueba antes de retirar el nombre o crea una nueva cola propia. En Linux, las funciones sin plazo también pueden aparecer internamente como llamadas temporales con un puntero de tiempo nulo. Observa los argumentos y el retorno, no solo el nombre de la llamada.
| Síntoma | Qué comprobar |
|---|---|
| La función temporal retorna enseguida con EAGAIN. | El descriptor puede tener O_NONBLOCK, incluso por una apertura heredada compartida. |
| Vence inmediatamente aunque se solicitaron segundos. | Se pasó una duración como fecha absoluta o se mezcló CLOCK_MONOTONIC con CLOCK_REALTIME. |
| La espera se prolonga con señales. | Se recalculó una fecha futura en cada EINTR, o cambió el reloj real. |
| El texto parece caber, pero mq_receive falla. | El búfer debe admitir mq_msgsize, no solo ese texto. |
| El consumidor muestra basura tras el mensaje. | Usó %s sin un NUL válido o imprimió más bytes que los retornados. |
| Un mensaje urgente no se procesa primero. | La tarea anterior pudo haberse retirado antes de su llegada. |
| El trabajador espera después de terminar el productor. | No existe EOF automático de cola; falta un protocolo de fin o un plazo. |
| Una respuesta no llegó y se duplicó una tarea. | Se reenvió un mensaje previamente aceptado sin identificación ni deduplicación. |
Consultar mq_curmsgs ayuda a observar la ocupación, pero no reserva una plaza ni un mensaje para la siguiente llamada. Las propiedades de apertura se describen en mq_getattr(3) y las particularidades de Linux en mq_overview(7).
17. Resumen
- mq_send devuelve cero al aceptar una unidad completa; mq_receive devuelve su longitud al retirarla.
- El contenido no necesita terminador NUL y puede incluir bytes cero.
- La capacidad receptora debe admitir mq_msgsize; cero recibido puede ser un mensaje vacío.
- La prioridad ordena mensajes pendientes, sin reordenar tareas ya retiradas ni garantizar equidad.
- O_NONBLOCK produce EAGAIN cuando falta progreso, también con las funciones temporales.
- Los tiempos de mq_timedsend y mq_timedreceive son fechas absolutas de CLOCK_REALTIME.
- Un reintento por EINTR conserva la misma fecha; no renueva el presupuesto.
- Un plazo vencido permite completar si la operación ya puede progresar.
- La aceptación, la retirada y el procesamiento confirmado son etapas distintas.
18. Preguntas de repaso y práctica
Responde antes de desplegar las explicaciones.
1. ¿Un mq_send exitoso devuelve la longitud?
No. Devuelve cero. La longitud se suministró como argumento y la unidad fue aceptada completa.
2. ¿Por qué el receptor no debe imprimir directamente con %s?
Porque el mensaje no tiene por qué terminar en NUL. Debe utilizar la longitud retornada o construir una cadena local con espacio adicional.
3. ¿Qué significa recibir cero bytes?
Que se retiró un mensaje vacío. No indica que hayan terminado todos los productores.
4. ¿Una recepción con prioridad alta interrumpe trabajo ya iniciado?
No. La prioridad decide qué mensaje pendiente se retira, no cómo se ejecuta una tarea que ya salió de la cola.
5. ¿Por qué mq_timedreceive puede devolver EAGAIN?
Porque O_NONBLOCK está activo y no hay mensaje disponible. La fecha límite no obliga a esperar en ese modo.
6. ¿Qué reloj interpreta la fecha de las funciones temporales?
CLOCK_REALTIME. Una lectura de CLOCK_MONOTONIC no se pasa directamente como esa fecha.
7. ¿Por qué hay que normalizar tv_nsec?
Porque debe estar entre cero y 999999999. Al sumar milisegundos puede ser necesario trasladar un segundo a tv_sec.
8. ¿Qué error introduce renovar la fecha en cada EINTR?
Prolonga la espera al devolver al proceso todo el intervalo en cada interrupción, en lugar de conservar el plazo inicial.
9. ¿Una fecha pasada hace fallar siempre?
No. Si hay contenido o espacio y la operación puede completar inmediatamente, puede tener éxito.
10. ¿Un timeout de recepción demuestra que una tarea enviada antes no se procesó?
No. Solo describe esa recepción. La tarea anterior pudo haberse retirado o completado sin que llegara su respuesta.
11. ¿La herramienta elimina la cola al terminar?
No. Cierra su referencia. El responsable de creación usa mq_admin u otro mecanismo del ciclo de vida para retirar el nombre.
12. ¿Un fallo al imprimir puede deshacer la recepción?
No. El mensaje ya se retiró. La recuperación necesita una decisión del protocolo; no debe asumirse un reencolado automático seguro.
Para practicar
- Envía tres mensajes con dos prioridades y recíbelos después. Repite iniciando primero un consumidor y explica la diferencia.
- Llena una cola pequeña y compara ahora con plazo. Verifica que no aparece el mensaje cuyo envío falló.
- Inicia una recepción con plazo y envía desde otro proceso antes de vencer. Comprueba el contenido y el estado de la orden.
- Prueba una prioridad inválida, texto superior a mq_msgsize y un nombre inexistente. Clasifica los errores.
- Ejecuta plazos_mq y explica por qué {0, 0} tiene éxito en unas operaciones y no cuando hace falta esperar.
- En una variante de laboratorio, instala un manejador sin SA_RESTART y envía señales durante una espera. Conserva la fecha y mide la duración con CLOCK_MONOTONIC.
- Usa el simulador para interrumpir varias veces una operación pendiente. Comprueba que no se mueve su límite.
- Diseña un resultado con identificador de tarea y una política de reintento tras perder la respuesta.
- Define cómo terminarían tres trabajadores sin adelantar mensajes de parada a las tareas pendientes.
El tema 22 integrará productores y trabajadores en un proyecto de reparto de tareas con cola POSIX, notificación mediante mq_notify y parada ordenada.