Tema 4 · 通过消息传递的通信

Tema 4: Comunicación mediante paso de mensajes
逐句对照版 · 讲义 23 页一页不省 · 一句西语 → 一句中文 → 考点解释 · 每页附原页截图 · 文末 A–Z 术语总表
怎么用这份讲义

一、封面与内容索引

p.1–p.2
p.1

Portada · 课程封面

▸ 原页截图 p.1 原讲义第 1 页

Sistemas Concurrentes y de Tiempo Real

并发与实时系统

Grado en Ingeniería Telemática

远程通信工程学士学位

Tema 4: Comunicación mediante paso de mensajes

主题 4:通过消息传递的通信

这一章是整门课的分水岭:前面几章都在共享内存里打转(信号量、互斥量、条件变量),从这一章起换赛道——进程之间不共享任何变量,只能靠「发消息」协作。后面所有代码(POSIX 消息队列、生产者/消费者、花园问题)都建立在这个前提上。
p.2

Índice de contenidos · 目录

▸ 原页截图 p.2 原讲义第 2 页

Índice de contenidos

目录

• Paso de Mensajes

• 消息传递

• Colas de mensajes

• 消息队列

2

页脚页码 2(讲义自印页码,与 PDF 物理页序一致)

整章只有两大块,考试大纲也照这个切:① Paso de Mensajes(概念 + 分类 + 同步/异步,p.3–p.13);② Colas de mensajes(POSIX API + 生产者/消费者 + 花园问题,p.14–p.23)。答题时先说「属于哪一块」,再展开。
目录只有两行,说明本章理论 11 页、实践 10 页,配比几乎 1:1——只背概念不写代码,实验题一定挂。

二、消息传递模型与分类

p.3–p.7
p.3

Paso de mensajes · 消息传递与弱耦合系统

▸ 原页截图 p.3 原讲义第 3 页

Paso de mensajes

消息传递

• En un sistema débilmente acoplado los procesos no comparten memoria por lo que

• 在一个弱耦合系统中,进程不共享内存,因此

– No pueden comunicarse a través de memoria compartida

– 它们不能通过共享内存通信

– El estado global instantáneo del sistema es desconocido

– 系统的瞬时全局状态是未知的

– Los mecanismos de sincronización estudiados (semáforos y mutex) no son aplicables

– 已学过的同步机制(信号量和互斥量)都不适用

– La comunicación se realiza mediante mecanismos de paso de mensajes:

– 通信改为通过消息传递机制实现:

emisor

发送方(图中左端)

Canal de comunicación

通信信道(图中中间那条通道)

mensaje

消息(在信道里流动的东西)

receptor

接收方(图中右端)

必背定义(考名词解释/简答):sistema débilmente acoplado = 进程间不共享内存,因此 ① 不能靠共享内存通信 ② 瞬时全局状态不可知 ③ 信号量/互斥量失效 ④ 只能靠消息传递。四条要按顺序写全,少一条扣一分。
「débilmente acoplado(弱耦合)」不要译成「松散连接」或「弱连接」。这里的「耦合」指的是共享状态:共享变量越少,耦合越弱。acoplamiento 与 comunicación 是两个词,答题时别混。
一句话记:不共享内存 → 状态看不见 → 信号量没抓手 → 只能寄快递。消息传递就是进程间的 EMS 快递:寄件人(emisor)、收件人(receptor)、运单(mensaje)、物流线(canal)。
p.4

Clasificación de las primitivas · 原语分类①:进程标识方式

▸ 原页截图 p.4 原讲义第 4 页

Paso de mensajes

消息传递

Clasificación de las primitivas de paso de mensajes

消息传递原语的分类

1. Identificación de los procesos emisor y receptor

1. 标识发送方与接收方进程

– Directa-Simétrica

– 直接-对称(收发双方都点名)

• send(ms,pidA)

• 发送:把消息 ms 发给进程 pidA(发送方必须写清收件人)

• receive(ms,pidB)

• 接收:只从进程 pidB 收消息(接收方也必须写清指定寄件人)

Directa-Asimétrica

直接-非对称(只有发送方点名)

• send(ms,pidA)

• 发送:仍然要写清收件人 pidA

• receive(ms)

• 接收:不写寄件人,任何人的消息都收(谁先来收谁)

– Indirecta-Simétrica a través de estructuras intermedias

– 通过中间结构的间接-对称方式

• send(ms,buzon)

• 发送:把消息投进邮箱 buzon(不直接寄给人)

• receive(ms,buzon)

• 接收:从同一个邮箱 buzon 取消息

• send(ms,canal)

• 发送:把消息写进通道 canal

• receive(ms, canal)

• 接收:从同一个通道 canal 读消息

emisor / receptor

图注:发送方 / 接收方

考「simétrica / asimétrica 的区别在哪」:看 receive 有没有写对方名字。Simétrica = 收发双方都点名(receive(ms,pidB));Asimétrica = 只有 send 点名,receive 不点名(receive(ms))。Directa 与 Indirecta 的区别是点的是「进程」还是「中间结构」。
三个易错点:① pidA 出现在 send 里的含义是「收件人」,不是发件人;② 课本原句里 buzon 写作 buzon(无重音),在 `.es` 中必须照抄 buzon,不能自作主张改成 buzón;③ Indirecta 之所以还叫 Simétrica,是因为收、发两边写的是同一个邮箱/通道名,形式上是「对称」的。
口诀:对称看 receive,直接看对象。receive 带名字 → 对称;receive 裸奔 → 非对称;对象是人 → 直接;对象是邮箱/通道 → 间接。
p.5

Clasificación · 间接通信的两种拓扑:点对点

▸ 原页截图 p.5 原讲义第 5 页

• Indirecta-Simétrica a través de estructuras intermedias

• 经由中间结构实现的间接-对称通信

• send(ms,canal) receive(ms, canal)

• 发送方写 send(ms,canal),接收方写 receive(ms, canal)——两边共用同一个通道名 canal

emisor / receptor

图注:发送方 / 接收方

Punto a punto unidireccional

点对点且单向(一个 emisor → 一个 receptor,箭头只朝一边)

emisor / receptor

图注(第二幅):发送方 / 接收方

Punto a punto bidireccional

点对点且双向(同两方之间来回都有箭头,通常要两条通道或一条双向通道)

考点:punto a punto 只约束「参与方数量」,unidireccional / bidireccional 约束「流向」。所以「点对点」≠「单向」:点对点可以是双向的。回答拓扑题时按「参与方数量 × 流向」两维作答。
双向并不等于「一条通道自动双向」。POSIX 消息队列没有方向,谁都能 send、谁都能 receive,所以做请求-应答(petición-respuesta)时通常要两条队列:一条去、一条回。这页图是概念图,别直接照搬成代码。
拓扑四宫格先记两格:1→1 单向(对讲机只听不说)、1→1 双向(打电话)。数量不变、方向翻倍。
p.6

Clasificación · 一对多与多对一

▸ 原页截图 p.6 原讲义第 6 页

• Indirecta-Simétrica a través de estructuras intermedias

• 经由中间结构的间接-对称通信

• send(ms,canal) receive(ms, canal)

• 收发双方都针对同一个 canal 操作

emisor / receptor / receptor

图注:一个发送方 + 两个接收方

De uno a muchos

一对多(发布/广播式:一个源,多个消费者)

emisor / receptor

图注(下幅):一个发送方、一个接收方

De muchos a uno

多对一(多个源汇聚到一个汇聚点)

emisor / emisor / emisor / receptor

图注:三个发送方 → 一个接收方

Punto a punto unidireccional

(页末重复给出对照图)点对点单向

emisor / receptor

图注:发送方 / 接收方

Punto a punto bidireccional

点对点双向

四种拓扑必背且要能画:punto a punto unidireccional / punto a punto bidireccional / de uno a muchos / de muchos a uno / de muchos a muchos(最后一种在 p.7)。答题模板:「N 个 emisor、M 个 receptor,中间通过 canal 连接,属于 X 拓扑」。
「uno a muchos」的中文习惯说「一对多」,但西语顺序是「从一到多」;「muchos a uno」是「从多到一」。写答案时别把方向写反——判卷时方向反了等于拓扑错。
把拓扑想成水管:一对多 = 一分水器(喷淋);多对一 = 汇流管(下水道);多对多 = 立交桥(p.7)。
p.7

Clasificación · 多对多

▸ 原页截图 p.7 原讲义第 7 页

Paso de mensajes

消息传递

• Indirecta-Simétrica a través de estructuras intermedias

• 经由中间结构的间接-对称通信

• send(ms,canal) receive(ms, canal)

• 所有参与者都对同一个 canal 收发,彼此不必知道对方是谁

receptor / receptor / receptor

图注:三个接收方

De muchos a muchos

多对多(若干发送方、若干接收方共享同一通道)

emisor / emisor / emisor

图注:三个发送方

多对多是消息队列的默认形态:任意进程 mq_open 同一个名字就能加入同一个 canal。考试常问「多对多如何实现」——答案就是间接通信 + 命名通道,中间结构替双方完成「解耦」。
这也解释了为什么后面 POSIX 消息队列的代码里,生产者和消费者从没见过对方:它们只共享一个字符串名字 "/PC"。名字就是 canal。
五种拓扑串成一句话:一对一单向、一对一双向、一对多、多对一、多对多——前两种画两框,后三种画一堆框围一个通道。

三、同步与异步:谁在等谁

p.8–p.13
p.8

2. Sincronización · 异步通信:接收方等消息

▸ 原页截图 p.8 原讲义第 8 页

Paso de mensajes

消息传递

Clasificación de las primitivas de paso de mensajes

消息传递原语的分类

2. Sincronización

2. 同步(第二个分类维度)

Comunicación asíncrona: el proceso receptor espera a que el mensaje esté listo para leerlo

异步通信:接收方进程等待消息就绪后才读取

A

A(发送方进程)

B

B(接收方进程)

send(ms,B)

A 执行 send(ms,B):把消息发给 B

receive(ms,A)

B 执行 receive(ms,A):从 A 收消息

B está bloqueado esperando el mensaje

B 处于阻塞状态,正在等这条消息(图中时间轴上的平段)

异步的定义只抓一句:发送方不被阻塞,接收方被阻塞直到消息可用。「asíncrona = 寄件人放下就走(邮筒),收件人必须守着信箱等」。
这一页的「espera a que el mensaje esté listo」容易被读反。它说的是接收方等消息,不是发送方等接收方。判断同步/异步只看发送方是否被阻塞:不阻塞 = 异步。
看时间轴:B 的那条线断了一截(被阻塞),A 的线一直连续——这就是异步。
p.9

2. Sincronización · 异步通信:传输瞬间谁都不阻塞

▸ 原页截图 p.9 原讲义第 9 页

Paso de mensajes

消息传递

Clasificación de las primitivas de paso de mensajes

消息传递原语的分类

2. Sincronización

2. 同步

Comunicación asíncrona: el proceso receptor espera a que el mensaje esté listo para leerlo

异步通信:接收方进程等待消息就绪后再读

A

A(发送方进程)

B

B(接收方进程)

send(ms,B)

A 执行 send(ms,B)

receive(ms,A)

B 执行 receive(ms,A)

Ni A ni B se bloquean durante la comunicación

通信进行中,A 和 B 都不阻塞(图中 A、B 两条时间轴的箭头段都是实线,没有平段)

这两页(p.8 与 p.9)是同一张异步时间轴的两个时刻:p.8 画的是「消息还没到,B 在等」;p.9 画的是「消息已经在通道里,双方都没停」。考试问「异步通信中是否有人阻塞」的标准答法是:发送方从不阻塞;接收方在消息未到达时阻塞,消息到达后即被唤醒。
如果只背 p.9 那句「Ni A ni B se bloquean」,会得出「异步没人阻塞」的错误结论。两句要合起来看:阻塞发生在等待期,不发生在传输期。原文没有勘误,但这是最容易被断章取义的一句。
把两页当成一段视频:p.8 = 缓冲中(B 卡住),p.9 = 已开播(两人都在跑)。
p.10

2. Sincronización · 同步通信:约会(cita)

▸ 原页截图 p.10 原讲义第 10 页

Paso de mensajes

消息传递

Clasificación de las primitivas de paso de mensajes

消息传递原语的分类

2. Sincronización

2. 同步

Comunicación síncrona: el proceso receptor espera a que el mensaje esté listo para leerlo, y el proceso emisor espera a que el receptor esté listo para enviar el mensaje

同步通信:接收方进程等待消息就绪,并且发送方进程等待接收方就绪后才发送

A

A(发送方进程)

B

B(接收方进程)

send(ms,B)

A 执行 send(ms,B)(必须等 B 进入接收状态才能返回)

receive(ms,A)

B 执行 receive(ms,A)

B está bloqueado esperando el mensaje

B 阻塞等待消息

cita

约会(图中标注:双方必须在同一时刻「碰面」,消息才算送达)

时刻发送方 A接收方 B说明
t1send(ms,B) 调用尚未 receiveA 阻塞,等 B 就绪
t2阻塞中receive(ms,A) 调用双方会合,消息直传
t3send 返回receive 返回两人同时解除阻塞
同步的判定句:send 阻塞直到对方 receive,receive 阻塞直到消息到达——两个方向都等,所以叫 cita(约会),也叫 rendezvous。答题时把「双方都阻塞」写出来就拿分。
不要把 síncrona(同步)与「同步机制 semáforo/mutex」混为一谈:前者指消息传递的等待语义,后者指共享内存下的互斥手段。本章恰恰说后者在弱耦合系统里不适用。
cita = 相亲:你没到,我也不坐下。谁先到谁等,两人同时在场才开始。
p.11

2. Sincronización · 同步通信:握手(handshake)

▸ 原页截图 p.11 原讲义第 11 页

Paso de mensajes

消息传递

Clasificación de las primitivas de paso de mensajes

消息传递原语的分类

2. Sincronización

2. 同步

Comunicación síncrona: el proceso receptor espera a que el mensaje esté listo para leerlo, y el proceso emisor espera a que el receptor esté listo para enviar el mensaje

同步通信:接收方等消息就绪,发送方等接收方就绪(与上页同一句,本页换成从 A 视角标注)

A

A(发送方进程)

B

B(接收方进程)

send(ms,B)

A 执行 send(ms,B)

receive(ms,A)

B 执行 receive(ms,A)

A espera a que B esté listo para enviarle el mensaje

A 等待 B 准备好接收,才能把消息交给它

handshake

握手(图中标注:发送前的「对表」动作)

cita

约会

p.10 与 p.11 是同一机制的两种画法:p.10 标 B 在等(接收方视角),p.11 标 A 在等(发送方视角)。考试要求「说明同步通信的双方阻塞关系」时,两个方向都要写,只写一个方向会被判不完整。
cita 与 handshake 在这份讲义里指同一件事,只是比喻不同:cita 强调「约好时间地点见面」,handshake 强调「通信前先确认对方在线」。写答案时用哪个都行,但要前后一致。
cita(约会)= 面对面交东西;handshake(握手)= 先碰个拳再传球。
p.12

2. Sincronización · 同步扩展通信:还要等回复

▸ 原页截图 p.12 原讲义第 12 页

Paso de mensajes

消息传递

Clasificación de las primitivas de paso de mensajes

消息传递原语的分类

2. Sincronización

2. 同步

Comunicación síncrona extendida: el proceso receptor espera a que el mensaje esté listo para leerlo, y el proceso emisor espera a que el receptor esté listo para enviar el mensaje, y espera su respuesta

同步扩展通信:接收方等消息就绪,发送方等接收方就绪,并且还要等对方的回复

A

A(发送方进程)

B

B(接收方进程)

send(ms,B)

A 发出请求消息 ms 给 B

receive(ms,A)

B 从 A 收到请求消息

A espera a que B esté listo para enviarle el mensaje

A 等 B 准备好接收

y espera la respuesta de B

并且(发送完成后)继续等 B 的应答

send(ans,A)

B 用 send(ans,A) 把应答 ans 回给 A

cita extendida

扩展约会(图中标注:一次完整的「请求—应答」往返)

三层递进的对比是必考表格题:asíncrona(只有接收方等)→ síncrona / cita(双方都等,消息一次交互结束)→ síncrona extendida / cita extendida(双方都等 + 发送方再等回复,共两次消息)。答题时按「阻塞方数量 + 消息次数」两个维度列。
原文写 «espera su respuesta»(等它的回复),图中标注写作 «y espera la respuesta de B»,两种表述指向同一件事,不是矛盾。另外 send(ans,A) 里的 A 是收件人,别看成发送方。
同步扩展 = RPC 打电话:你说完还不能挂,得听到「收到」才算完成。一次 cita 是「递纸条」,cita extendida 是「递纸条 + 等回执」。
p.13

2. Sincronización · 同步扩展:从接收方视角看

▸ 原页截图 p.13 原讲义第 13 页

Paso de mensajes

消息传递

Clasificación de las primitivas de paso de mensajes

消息传递原语的分类

2. Sincronización

2. 同步

Comunicación síncrona extendida: el proceso receptor espera a que el mensaje esté listo para leerlo, y el proceso emisor espera a que el receptor esté listo para enviar el mensaje, y espera su respuesta

同步扩展通信:接收方等消息、发送方等接收方、发送方再等回复(与 p.12 同一句,本页换视角标注)

A

A(发送方进程)

B

B(接收方进程)

send(ms,B)

A 发出请求消息 ms

receive(ms,A)

B 收到来自 A 的请求

B espera a que A esté listo para enviarle el mensaje

B 等待 A 就绪(即 B 自己阻塞在 receive 上,等 A 来消息)

y A espera la respuesta de B

而 A 则在等 B 的应答

send(ans,A)

B 执行 send(ans,A) 发出应答

cita extendida

扩展约会

模式发送方阻塞?接收方阻塞?消息次数讲义用词
异步否是(等消息)1asíncrona
同步是(等对方就绪)是(等消息)1síncrona / cita / handshake
同步扩展是(还要等回复)是2síncrona extendida / cita extendida
这张三行表就是本章最可能出的简答题答案。判分点三个:谁阻塞、几条消息、西语原名。写「síncrona extendida = 双方阻塞 + 两条消息(请求 + 应答)」即可拿满。
原文 p.13 写「B espera a que A esté listo para enviarle el mensaje」,字面是「B 等 A 准备好发消息」。不要理解成「B 在等 A 空闲」——它的实际含义就是 B 阻塞在 receive 上。这是讲义按接收方视角改写的标注,不是新机制。
三步走:异步=单向等,同步=双向等,同步扩展=双向等 + 回执。等的人数不变,只是多了一次往返。

四、POSIX 消息队列:从概念到 API

p.14–p.18
p.14

Colas de mensajes · 消息队列与管道的四点差异

▸ 原页截图 p.14 原讲义第 14 页

Colas de mensajes

消息队列

• Un mecanismo POSIX eficiente de comunicación asíncrona entre procesos/hebras

• 一种 POSIX 提供的高效的异步通信机制,用于进程/线程之间

• Es parecido a los pipes de Linux pero existen diferencias:

• 它很像 Linux 的管道,但存在以下差异:

– Las colas de mensajes tienen una estructura interna

– 消息队列具有内部结构(不是字节流,每条消息有边界)

– Se puede asignar una prioridad a los mensajes

– 可以给消息指定优先级

– El programador tiene el control sobre la cola de mensajes

– 程序员对消息队列拥有控制权

– Se puede conocer el estado de la cola de mensajes

– 可以查询消息队列的状态(如当前有多少条消息)

「四条差异」是标准简答题,按顺序背:① 有内部结构 ② 可设优先级 ③ 程序员可控制 ④ 可查询状态。每条要能对上一句西语关键词:estructura interna / prioridad / control / estado。答出三条给及格,四条齐全给满分。
注意「hebras」是西语对「线程」的说法(拉美用法,西班牙本土多说 hilos),与 procesos 并列出现。别把 hebras 当成「纤维」或某个硬件概念。
四差异记成「有结构、有级别、有主控、有仪表盘」——管道是「裸水管」,消息队列是「带分拣机和仪表的快递柜」。
p.15

Colas de mensajes · mq_open:创建/打开队列

▸ 原页截图 p.15 原讲义第 15 页

Colas de mensajes

消息队列

#include <mqueue.h>

头文件:#include <mqueue.h>(POSIX 消息队列全部原语都在这里)

mqd_t mq_open(char *name, int flag, mode_t mode, mq_attr *attr);

mqd_t mq_open(char *name, int flag, mode_t mode, mq_attr *attr);——打开或创建队列,返回队列描述符

Crea una cola de mensajes con nombre y atributos attr:

创建一个带名字、带属性 attr 的消息队列:

Número máximo de mensajes.

(attr 第 1 项)队列中消息的最大条数。

Tamaño máximo del mensaje.

(attr 第 2 项)单条消息的最大字节数。

Bloqueante, No bloqueante.

(attr 第 3 项)阻塞 / 非阻塞标志。

Flags

Flags(打开方式标志)

O_RDWR|O_CREAT

O_RDWR|O_CREAT:可读写,且不存在就创建

Modos

Modos(权限位)

(S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH)

(S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH):属主读+写、同组读、其他读

El propietario puede leer y escribir. El grupo puede leer. Otros usuarios pueden leer.

属主可读可写;用户组可读;其他用户可读。

¿Qué significa?

「这是什么意思?」(教师旁注气泡,指向上面 attr 的三个字段)

/* 原页函数原型(逐字照抄) */
mqd_t mq_open(char *name, int flag, mode_t mode, mq_attr *attr);

/* 实际调用时的四个实参 */
idcola = mq_open("/PC",                       /* name:以 / 开头的名字 */
                 O_RDWR|O_CREAT,              /* flag:可读写 + 不存在则创建 */
                 (S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH), /* mode:权限 */
                 &attr);                       /* attr:队列属性 */

mq_open 调用形态 · Tema 4 · Paso de mensajes · p.15

这段在考什么:四个参数各是什么,以及 flag 与 mode 的分工。答题模板:「mq_open 的 name 必须以 / 开头;flag 用 O_RDWR|O_CREAT 表示读写并无则创建;mode 用 S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH 给出属主读写、组读、其他读;attr 给队列上限。」
原文原型写作 mq_attr *attr,标准声明应为 struct mq_attr *attr(C 里 struct 关键字不能省,除非另有 typedef)。这是原页的省略写法,抄笔记时建议补全 struct,否则编译报错。另外 name 在标准里是 const char *。
四参数记成「名字、方式、权限、属性」——像开信箱:报箱号、说要开还是要造、谁能开、箱子多大。
p.16

Colas de mensajes · struct mq_attr 与 mq_close

▸ 原页截图 p.16 原讲义第 16 页

Colas de mensajes

消息队列

struct mq_attr {

struct mq_attr {——队列属性结构体开始

long mq_flags; /* Flags: 0 o O_NONBLOCK */

long mq_flags; 标志位:0 或 O_NONBLOCK

long mq_maxmsg; /* Max. número de mensajes en la cola */

long mq_maxmsg; 队列中消息的最大条数

long mq_msgsize; /* Maximo tamaño de mensaje(bytes) */

long mq_msgsize; 单条消息的最大字节数

long mq_curmsgs; /* Número de mensajes actuales en la cola (solo lectura) */

long mq_curmsgs; 队列当前消息条数(只读)

};

};——结构体结束

int mq_close (mqd_t mqdes);

int mq_close (mqd_t mqdes);——关闭队列描述符

– Cierra una cola de mensajes.

– 关闭一个消息队列(只释放本进程的句柄,不删除队列本身)

字段西语注释读法中文含义可写?
mq_flags«flags: cero o o-nonblock»阻塞/非阻塞标志可写
mq_maxmsg«máximo número de mensajes en la cola»队列容量上限(条)创建时写
mq_msgsize«máximo tamaño de mensaje, en bytes»单条消息最大字节创建时写
mq_curmsgs«número de mensajes actuales»当前条数只读
最常问的是「哪个字段只读」——mq_curmsgs。它也正是 p.14 说的「可以知道队列状态」的落地方式:读 mq_curmsgs 就知道积压了多少条。
mq_close ≠ mq_unlink。close 只是关闭本进程的句柄,队列和里面的消息还在(别的进程还能继续用);只有 unlink 才真正把队列从系统里移除。考试极爱在这里设陷阱。另外原文注释里 «Maximo» 缺重音,规范写法是 «Máximo»,属原页笔误,不影响语义。
四个字段记成「旗、量、尺、数」:旗(flags)决定等不等,量(maxmsg)决定装几条,尺(msgsize)决定每条多大,数(curmsgs)告诉你现在几条——只有「数」是只读的。
p.17

Colas de mensajes · mq_send 与 mq_receive

▸ 原页截图 p.17 原讲义第 17 页

Colas de mensajes

消息队列

int mq_send(mqd_t mqdes, char *msg, size_t len, int prio);

int mq_send(mqd_t mqdes, char *msg, size_t len, int prio);——发送一条消息

– Envía el mensaje msg de longitud len (<= mqsize) a la cola de mensajes mqdes con prioridad prio

– 把长度为 len(≤ mqsize)的消息 msg 发送到队列 mqdes,并带上优先级 prio

– Si la cola está llena el envío puede ser bloqueante o no.

– 若队列已满,发送可以阻塞,也可以不阻塞(取决于 flags)

int mq_receive(mqd_t mqdes, char *msg, size_t len, int *prio);

int mq_receive(mqd_t mqdes, char *msg, size_t len, int *prio);——接收一条消息

– Recibe un mensaje en la variable msg donde len >= mqsize. La prioridad del mensaje se recibe en el parámetro prio

– 把消息收到变量 msg 中,要求 len ≥ mqsize;该消息的优先级通过参数 prio 带回

– Recepción bloqueante o no.

– 接收同样可以阻塞或不阻塞

原语参数方向长度约束prio 的含义
mq_sendmqdes, msg, len, prio进程 → 队列len <= mqsize传入消息的优先级
mq_receivemqdes, msg, len, &prio队列 → 进程len >= mqsize传出消息的优先级
两个不等式是送分点也是失分点:send 用 ≤,receive 用 ≥。因为 send 只搬 len 个字节,缓冲区不能超过消息上限;receive 必须准备足够大的缓冲区,否则装不下最大消息。答「为什么 receive 要 ≥」时就说:缓冲区必须能容纳队列允许的最大消息。
原文写 «len >= mqsize»,其中 mqsize 指的是 attr.mq_msgsize(单条消息最大字节),不是 mq_maxmsg(条数)。把两者搞反是本页最常见的错误。
记成「发货可以小,收货必须大」:寄件人拿小盒子也行,收件人得备一个能装下最大件的箱子。
p.18

Colas de mensajes · mq_unlink:先清场再开工

▸ 原页截图 p.18 原讲义第 18 页

Colas de mensajes

消息队列

Comunicación asíncrona

页面横幅:异步通信(本节的机制定位)

int mq_unlink(const char *name);

int mq_unlink(const char *name);——按名字删除队列

Esta función elimina el contenido de la cola de mensajes con nombre name

该函数删除名为 name 的消息队列的内容(连同队列本身一并从系统中移除)

Normalmente, será lo primero que hagamos en los programas para asegurarnos de que no hay mensajes de ejecuciones previas

通常它会是程序里最先做的事,以确保不残留上次运行留下的消息

/* 程序开头的标准三连(顺序不能颠倒) */
mq_unlink("/PC");                                  /* ① 先清掉上次残留 */
idcola = mq_open("/PC", O_RDWR|O_CREAT,             /* ② 再创建/打开 */
                 (S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH), &attr);
/* ③ 最后才 pthread_create 起生产者和消费者 */

清场顺序 · Tema 4 · Paso de mensajes · p.18

这段在考什么:为什么 unlink 要放在最前面。标准答法:POSIX 消息队列是内核持久对象,程序退出后仍然存在(只有 unlink 才删除),若不先清掉,本次运行会读到上次遗留的消息,导致生产者/消费者对不上号。
两个坑:① mq_unlink 的参数是 名字字符串("/PC"),不是队列描述符 idcola;② 名字必须以 / 开头且整体只有一个 /(形如 /PC,不是 /tmp/PC)。
把 unlink 想成「进实验室先清台面」:不擦桌子,上一位的实验残留物会混进你的结果里。

五、完整实例:生产者 / 消费者与花园问题

p.19–p.23
p.19

Productor/Consumidor · int main():建队列、起线程

▸ 原页截图 p.19 原讲义第 19 页

Productor/Consumidor

生产者/消费者——本节完整实例

#include <mqueue.h>

#include <mqueue.h>——消息队列整套 API(mq_open/mq_send/mq_receive)

#include <pthread.h>

#include <pthread.h>——hebras:pthread_create/pthread_join

#include <sys/stat.h>

#include <sys/stat.h>——提供权限宏 S_IRUSR 等

#include <stdio.h>

#include <stdio.h>——printf

mqd_t idcola;

mqd_t idcola;——全局队列描述符,两个线程共用同一个句柄

int main () {

int main () {——主线程只负责「搭场景」,干活交给两个 hebra

struct mq_attr attr;

struct mq_attr attr;——声明atributos结构体变量(栈上,未初始化)

pthread_t th1,th2;

pthread_t th1,th2;——两个线程标识:th1 生产者、th2 消费者

pthread_attr_t attrh;

pthread_attr_t attrh;——线程atributos(注意与上面 mq_attr 是两种不同的结构体)

// Atributos de la cola de mensajes

// 消息队列的属性——下面三行才是队列属性

attr.mq_maxmsg = 10;

attr.mq_maxmsg = 10;——队列最多容纳 10 条消息

attr.mq_msgsize = sizeof(int);

attr.mq_msgsize = sizeof(int);——每条消息恰好一个 int(通常 4 字节)

attr.mq_flags = 0;

attr.mq_flags = 0;——0 表示阻塞模式(不加 O_NONBLOCK)

pthread_attr_init(&attrh);

pthread_attr_init(&attrh);——线程属性先初始化再用,不能直接传未初始化的 attrh

mq_unlink("/PC");

mq_unlink("/PC");——先清掉上次运行残留的队列(名字 "/PC")

idcola=mq_open("/PC",O_RDWR|O_CREAT,(S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH),&attr);

idcola=mq_open("/PC",O_RDWR|O_CREAT,(S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH),&attr);——创建并打开队列,返回描述符存进 idcola

pthread_create(&th1,&attrh,productor,NULL);

pthread_create(&th1,&attrh,productor,NULL);——创建生产者线程,入口函数 productor

pthread_create(&th2,&attrh,consumidor,NULL);

pthread_create(&th2,&attrh,consumidor,NULL);——创建消费者线程,入口函数 consumidor

pthread_join (th1,NULL);

pthread_join (th1,NULL);——主线程在此等 th1(而 th1 是 while(1) 死循环,实际永远等不到)

printf("Fin\n");

printf("Fin\n");——只有 th1 结束才会打印「Fin」,因此这行在实践中几乎不会执行

return 0;

return 0;——主线程正常返回

}

}——main 结束;没有 mq_close/mq_unlink 收尾

/* 全局:两个线程共用同一个队列描述符 */
mqd_t idcola;

int main () {
  struct mq_attr attr;
  pthread_t th1,th2;
  pthread_attr_t attrh;

  /* ① 队列属性:装 10 条、每条一个 int、阻塞模式 */
  attr.mq_maxmsg  = 10;
  attr.mq_msgsize = sizeof(int);
  attr.mq_flags   = 0;

  pthread_attr_init(&attrh);

  mq_unlink("/PC");                        /* ② 清场 */
  idcola = mq_open("/PC", O_RDWR|O_CREAT,  /* ③ 建队列 */
        (S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH), &attr);

  pthread_create(&th1, &attrh, productor,  NULL);  /* ④ 起线程 */
  pthread_create(&th2, &attrh, consumidor, NULL);

  pthread_join (th1, NULL);
  printf("Fin\n");
  return 0;
}

main.c · 生产者/消费者主程序 · Tema 4 · Paso de mensajes · p.19

步骤语句如果不写会怎样
① 填属性attr.mq_maxmsg / mq_msgsize / mq_flagsattr 是栈上未初始化值,mq_open 会拿到垃圾容量
② 清场mq_unlink("/PC")读到上次运行残留的消息,生产/消费对不上号
③ 建队列mq_open(..., &attr)后面所有 mq_send/receive 无句柄可用
④ 起线程pthread_create × 2队列建好但没人读写,程序停在 pthread_join
这段在考什么:main 的职责边界——只做四件事「填属性 → 清场 → 建队列 → 起线程」,真正的收发全部落在 productor / consumidor 里。问「idcola 为什么声明为全局」就答:两个线程的函数都要用它,而 pthread_create 的第四个参数本题传的是 NULL,没有通过参数传递句柄。
两个陷阱:① struct mq_attr attr 与 pthread_attr_t attrh 是两种完全不同的结构体,前者描述队列、后者描述线程,混用必编译失败;② 本例没有写 mq_close(idcola),也没有在退出前 mq_unlink,属于教学简化——严格实现应当在 join 之后补上收尾。
main 的四个动作记成「填、擦、建、起」:填属性、擦台面(unlink)、建队列(open)、起线程(create)。顺序错了就出问题,尤其别把 unlink 放到 open 后面。
p.20

Productor/Consumidor · productor:mq_send 死循环

▸ 原页截图 p.20 原讲义第 20 页

Productor/Consumidor

生产者/消费者

void *productor(void *argg ){

void *productor(void *argg ){——线程入口:返回 void*、接收 void*(本例 argg 未使用)

int i=0, prio=0;

int i=0, prio=0;——prioridad 固定为 0(i 声明后从未使用)

// Suponemos un dato cualquiera. Lo iremos incrementando

// 假设有一个任意数据,我们会不断把它加一

int dato=0;

int dato=0;——真正被发送的变量,初值 0

char *buff;

char *buff;——指针,只作「字节视角」的临时别名,不分配缓冲

while (1) {

while (1) {——无限生产:队列满了就在 mq_send 里阻塞等待

buff=&dato;

buff=&dato;——让 buff 指向 dato 的首字节地址

if (mq_send (idcola, (const char *)buff, sizeof(int), prio) == -1)

if (mq_send (idcola, (const char *)buff, sizeof(int), prio) == -1)——向队列发送 sizeof(int) 个字节,返回 -1 即失败

{

{——失败分支开始

printf("Error\n"); fflush(stdout);

printf("Error\n"); fflush(stdout);——打印错误并强制刷新输出缓冲

}

}——失败分支结束(没有 break,出错也继续循环)

dato=(dato+1) % 10000;

dato=(dato+1) % 10000;——自增并在 10000 处回绕,保证数值始终有限

}

}——while 结束

}

}——函数结束(没有 return,因为永远进不来)

void *productor(void *argg ){
  int i=0, prio=0;
  // Suponemos un dato cualquiera. Lo iremos incrementando
  int dato=0;
  char *buff;

  while (1) {
    buff = &dato;                    /* 取 dato 的地址,按字节发送 */
    if (mq_send (idcola, (const char *)buff, sizeof(int), prio) == -1)
    {
      printf("Error\n"); fflush(stdout);
    }
    dato = (dato+1) % 10000;       /* 0..9999 循环 */
  }
}

productor.c · 生产者线程 · Tema 4 · Paso de mensajes · p.20

时刻dato被发送的 4 字节prio队列状态
t100x00 0x00 0x00 0x0001/10
t210x01 0x00 0x00 0x0002/10
t3……0满 10 条后 阻塞
t499990x0F 0x27 0x00 0x000下一次回到 0
这段在考什么:三处必须解释清楚的写法。① buff=&dato + (const char*)buff:mq_send 只认「字节流 + 长度」,所以要把 int 的地址强转成 char*;② 第三个参数 sizeof(int) 必须正好等于 attr.mq_msgsize(p.19 设的就是它);③ prio 恒为 0,等于放弃了优先级能力,队列退化为纯粹 FIFO。
注意 mq_send 只把发送那一刻的 4 个字节拷进内核,之后 dato 怎么改都与已入队的消息无关——这正是「消息传递不共享内存」的直接体现。反过来,若误传 &dato 的长度写成 sizeof(dato) 以外的值(例如 sizeof(int*)=8),就会与 mq_msgsize 不匹配而 EMSGSIZE。
记成「发一份复印件,不是发原件」:把 dato 的值复印 4 个字节投进邮箱,原件之后怎么改,信已经寄出去了。
p.21

Productor/Consumidor · consumidor:mq_receive 死循环

▸ 原页截图 p.21 原讲义第 21 页

Productor/Consumidor

生产者/消费者

void *consumidor(void *argg ){

void *consumidor(void *argg ){——消费者线程入口,与生产者签名完全一致

int *dato;

int *dato;——准备一个 int*,用来解释收到的字节

unsigned int prio;

unsigned int prio;——接收端用来带回消息优先级的变量(此处收完不用)

char buff[4];

char buff[4];——真正的接收缓冲区,硬编码 4 字节

while (1) {

while (1) {——无限消费:队列空就在 mq_receive 里阻塞等

mq_receive (idcola, &(buff[0]), 4, &prio);

mq_receive (idcola, &(buff[0]), 4, &prio);——从队列取一条,装进 buff,优先级写入 prio

dato=&(buff[0]);

dato=&(buff[0]);——把 int* 指向缓冲区首字节,等价于 dato=buff

//sleep(1);

//sleep(1);——被注释掉的节流语句:想演示「慢消费」时取消注释即可

printf("Dato Consumido =%d\n",*dato);

printf("Dato Consumido =%d\n",*dato);——解引用打印收到的整数(原文 ",*dato" 中间无空格,照抄)

}

}——while 结束

}

}——函数结束

void *consumidor(void *argg ){
  int *dato;
  unsigned int prio;
  char buff[4];                  /* 缓冲区 = 一条消息的最大字节数 */

  while (1) {
    mq_receive (idcola, &(buff[0]), 4, &prio);  /* 阻塞直到有消息 */
    dato = &(buff[0]);           /* 按 int 解释这 4 个字节 */
    //sleep(1);                  /* 打开即可放慢消费速度 */
    printf("Dato Consumido =%d\n", *dato);
  }
}

consumidor.c · 消费者线程 · Tema 4 · Paso de mensajes · p.21

这段在考什么:接收端两个参数的方向。第三个参数 4 必须 ≥ mq_msgsize(p.17 的规则),这里恰好相等;第四个参数传的是地址 &prio,因为优先级是 mq_receive 往外写的结果(int *prio)。此外 &(buff[0]) 与 buff 完全等价,两种写法都要认得出。
char buff[4] 把「int 是 4 字节」写死了。规范写法是 char buff[sizeof(int)] 或直接用 attr.mq_msgsize 来定长——换平台(int 不是 4 字节)时硬编码会静默出错。另外生产者用 sizeof(int)、消费者用字面量 4,两者「碰巧」相等,是这类代码最常见的隐患。
生产者/消费者是一对镜像:生产 地址→字节→长度,消费 长度→字节→地址;发送端传值 prio,接收端传址 &prio。
p.22

El problema de los jardines · 花园问题:为什么死等两次

▸ 原页截图 p.22 原讲义第 22 页

El problema de los jardines

花园问题——同一个计数器、两道门(两个入口)的场景

void *IncVisitantes(void *arg) {

void *IncVisitantes(void *arg) {——统计入园人数的线程:IncVisitantes = 增加访客数

int *dato;

int *dato;——解释缓冲区用的指针

unsigned int prio;

unsigned int prio;——接收优先级(同样未使用)

char buff[4];

char buff[4];——4 字节接收缓冲

while (1) {

while (1) {——每轮循环固定处理两条消息

mq_receive (idcola, &(buff[0]), 4, &prio);

第一次 mq_receive (idcola, &(buff[0]), 4, &prio);——收门 1 的到达人数

dato=buff;

dato=buff;——指向缓冲区(此处直接写 buff,比 p.21 的 &(buff[0]) 更简洁)

Visitantes=Visitantes+(*dato);

Visitantes=Visitantes+(*dato);——累加到全局计数 Visitantes

mq_receive (idcola, &(buff[0]), 4, &prio);

第二次 mq_receive (idcola, &(buff[0]), 4, &prio);——收门 2 的到达人数;问题就出在这一行

dato=buff;

dato=buff;——重新指向缓冲区(同一块内存被覆盖)

Visitantes=Visitantes+(*dato);

Visitantes=Visitantes+(*dato);——再累加一次

printf("Vsitantes %d\n", Visitantes);

printf("Vsitantes %d\n", Visitantes);——打印累计值(原文拼写为 Vsitantes,少一个 i,照抄)

sleep (2);

sleep (2);——暂停 2 秒,模拟「每 2 秒结算一次」

}

}——while 结束

}

}——函数结束

void *IncVisitantes(void *arg) {
  int *dato;
  unsigned int prio;
  char buff[4];

  while (1) {
    mq_receive (idcola, &(buff[0]), 4, &prio);  /* ① 等门 1 */
    dato=buff;
    Visitantes = Visitantes + (*dato);

    mq_receive (idcola, &(buff[0]), 4, &prio);  /* ② 死等门 2 */
    dato=buff;
    Visitantes = Visitantes + (*dato);

    printf("Vsitantes %d\n", Visitantes);  /* 原文笔误:应为 Visitantes */
    sleep (2);
  }
}

IncVisitantes.c · 花园问题 · Tema 4 · Paso de mensajes · p.22

El problema de esta solución es que impone un orden de llegada a las personas por cada puerta.

这个解法的问题在于:它给每道门的人都强加了一个到达顺序。

Así, por ejemplo, si primero llegaran 20 personas seguidas por la Puerta2,

举例来说,如果先有 20 个人连续从 2 号门进来,

tendrían que esperar a que llegaran todas las que entran por la Puerta1.

那他们就得等 1 号门的人全部到齐(因为循环里第二次 receive 死等门 1)

这段在考什么:两次 mq_receive 造成的「门间锁步」。代码隐含假设「门 1 一条、门 2 一条」交替到达,可队列是 FIFO(prio 恒 0),实际到的是「先到先排」。于是门 2 的 20 个人只能先躺在队列里,直到门 1 有人来凑数,统计才往前走——吞吐被最慢的那道门锁死。正确做法:每条消息带上门编号,一次 receive 拿一条,按编号累加到各自的计数。
原文 printf("Vsitantes %d\n", …) 是笔误,正确拼写 Visitantes——本节照抄原文,但答题时不要跟着写错。另外 dato=buff 让指针始终指向同一块 buff,第二次 receive 会覆盖第一次的内容,所以两次累加必须紧跟在各自 receive 之后,顺序不能调换。
把这段想成「两个检票口共用一条传送带」:传送带只按到达先后排队,却硬要求「1 号口一张、2 号口一张」交替过闸,一方的空档就会把整条带子堵住。
p.23

En resumen… · 本章小结

▸ 原页截图 p.23 原讲义第 23 页

En resumen…

总结……——四条收束要点

• Hemos visto un modelo diferente sin compartición de memoria

• 我们看到了一个不共享内存的不同模型

• Diferentes modos: uno a uno, muchos a muchos

• 多种模式:uno a uno、muchos a muchos

• Síncrono vs asíncrono

• Síncrono vs asíncrono

• Colas de mensajes como mecanismo POSIX

• Colas de mensajes作为 POSIX 机制

这四条就是本章的答题骨架:① 模型层面——消息传递不共享内存,因此天然弱耦合,信号量/mutex 那套共享内存工具不适用;② 拓扑层面——从 uno a uno 到 muchos a muchos;③ 同步层面——asíncrono(发送方不等)/ síncrono(双方都等,cita)/ cita extendida(还要等回复);④ 实现层面——POSIX 消息队列是 Linux 上的落地机制,靠 mq_open / mq_send / mq_receive / mq_close / mq_unlink 五个函数操作。
一句话背下整章:「不共享内存、四种拓扑、三种同步、五个函数」——模型、模式、同步、API,四层各一句。

六、专有名词总表(A–Z)

全章 23 页

专有名词速记表(A–Z)

按西语字母排序,点页码直接跳回对应页块。最后一列是「一句话记住 / 易错点」——考前只扫这一列也能救急。

西语术语中文页一句话记住 / 易错点
A
acoplamiento débil弱耦合p.3不共享内存 → 只能靠消息通信,这是全章的逻辑起点
asíncrona (comunicación)异步通信p.8只有接收方阻塞,发送方发完就走
atributos de la cola队列属性p.19maxmsg / msgsize / flags 三项,open 之前必须填好
B
bidireccional双向p.5同一对进程互相收发,两条方向各一条链路
bloqueante阻塞的p.17队列空/满时调用不返回,进程被挂起等待
buzón信箱p.4间接通信的中间结构;原文写作 buzon(无重音)
C
canal通道p.4与 buzón 并列的间接结构,写法 send(ms,canal)
cita会合 / 约会p.10同步通信:双方都阻塞,见面才交接
cita extendida扩展会合p.12会合后再等一句回复,全程两条消息
cola de mensajes消息队列p.14POSIX 的高效异步机制,可跨进程也可跨 hebra
compartición de memoria内存共享p.23本模型没有它——这是全章最核心的一句
consumidor消费者p.21只做 mq_receive,缓冲区要够大(≥ 消息长度)
D
Directa-Asimétrica直接·不对称p.4接收方写 receive(ms):不点名,谁来都收
Directa-Simétrica直接·对称p.4双方都点名:send(ms,pidA) / receive(ms,pidB)
E
emisor发送方p.3图里左侧那个箭头起点,对应 send
estructuras intermedias中间结构p.4buzón 与 canal 的统称,间接通信全靠它解耦
H
hebra线程p.14消息队列既能在 procesos 间、也能在 hebras 间通信
I
Identificación de los procesos进程标识方式p.4分类第 1 维:直接 / 间接 × 对称 / 不对称
Indirecta-Simétrica间接·对称p.4双方都写同一个 buzon/canal 名,靠中间结构会合
M
mensaje消息p.3通信的最小单位,走 canal 从 emisor 到 receptor
muchos a muchos多对多p.73 emisor + 3 receptor,拓扑里最一般的情形
muchos a uno多对一p.6多个 emisor 汇到一个 receptor,天然汇聚点
mq_attr队列属性结构体p.16四个字段:flags / maxmsg / msgsize / curmsgs
mq_close关闭队列句柄p.16只关本进程句柄,队列还在
mq_curmsgs当前消息条数p.16四个字段里唯一只读的
mq_flags队列标志位p.160 = 阻塞;O_NONBLOCK = 不阻塞
mq_maxmsg最大消息条数p.19本例 = 10,是容量不是字节数
mq_msgsize单条消息最大字节p.19本例 sizeof(int),决定收发缓冲大小
mq_open创建/打开队列p.15四参数:名字、flags、权限模式、属性
mq_receive接收消息p.17要求 len >= mqsize,prio 是出参
mq_send发送消息p.17要求 len <= mqsize,prio 是入参
mq_unlink删除队列p.18参数是名字不是句柄,程序第一步就调用
mqd_t队列描述符类型p.15相当于队列的「文件描述符」,全局共享一个
O
O_NONBLOCK非阻塞标志p.16置位后队列空/满时立刻返回,不死等
orden de llegada到达顺序p.22花园问题的病根:强加交替顺序 → 快门被慢门拖死
P
paso de mensajes消息传递p.3弱耦合系统里唯一可用的通信范式
pipe管道p.14消息队列最像它,但多了优先级/状态/控制/结构
prioridad优先级p.15消息队列相对 pipe 的关键增强,可指定取哪条
productor生产者p.20只做 mq_send,长度必须 ≤ mq_msgsize
Puerta1 / Puerta21 号门 / 2 号门p.22花园问题的两个入口,对应两条消息来源
Punto a punto点对点p.5一对一,再分单向 / 双向两种画法
R
receptor接收方p.3对应 receive,异步时它是唯一阻塞的一方
receive(ms, buzon)从信箱接收p.4间接通信的接收原语,与 send 必须同名同结构
S
semáforo信号量p.3共享内存时代的同步工具,在本模型不适用
send(ms, pidA)定向发送p.4直接通信的发送原语,第二个参数是收件进程
Sincronización同步方式p.8分类第 2 维:异步 / 同步 / 同步扩展
síncrona (comunicación)同步通信p.10双方都阻塞,必须 cita 才会合
U
unidireccional单向p.5只有 emisor → receptor 一个箭头
uno a muchos一对多p.6一个 emisor 广播,多个 receptor 各收一份
uno a uno一对一p.5最基础拓扑,其余都是它的叠加
V
Visitantes访客(计数)p.22原文 printf 误拼 Vsitantes,答题别跟着错

七、编号与规则速记卡

背诵版

两条分类轴 + 四点差异 + 五个函数

原文只给编号不给总结,这三张表把「1. Identificación」「2. Sincronización」和 POSIX 接口全部压成可背的形式。

编号名称三个取值一句话
1Identificación de los procesosDirecta-Simétrica / Directa-Asimétrica / Indirecta-Simétrica看「有没有中间结构」和「接收方点不点名」
2SincronizaciónAsíncrona / Síncrona (cita) / Cita extendida看「谁在阻塞」:一方法、双方、双方加回程
#Colas de mensajes vs pipes(原文四点差异)中文
1estructura interna队列有内部结构,消息按边界成条,不是纯字节流
2prioridad可以给消息指定优先级,接收方可挑着取
3control del programador程序员对队列本身有控制权(建、删、设属性)
4estado de la cola可以查询队列状态(mq_curmsgs)
#函数作用关键约束
1mq_open创建/打开命名队列名字以 / 开头;flags 用 O_RDWR|O_CREAT
2mq_send投递一条消息len <= mq_msgsize
3mq_receive取走一条消息len >= mq_msgsize;prio 传地址
4mq_close关闭本进程句柄队列与消息仍然存在
5mq_unlink按名字删除队列程序第一步调用,清掉上次残留
三条口诀串起来背:分类轴「识别的看中间,同步的看谁等」;差异「结构、优先、控制、状态」;函数「开、发、收、关、删」。

八、易混概念对照卡

考前 3 分钟

15 组最容易写反的概念

左格与右格只差一个关键词——考场上问「区别是什么」,答的就是那一句。

Directa
原语里写进程:send(ms,pidA)。
Indirecta
原语里写中间结构:send(ms,buzon) / (ms,canal)。
Simétrica
收发双方都点名,一一对应。
Asimétrica
接收方不点名:receive(ms),谁来都收。
Asíncrona
只有接收方阻塞等消息,发送方发完继续跑。
Síncrona
双方都阻塞,cita 会合才交接。
Cita
会合即结束,全程一条消息。
Cita extendida
会合后还要回一句:send(ans,A),共两条。
Punto a punto unidireccional
一个箭头,只有 emisor → receptor。
Punto a punto bidireccional
两个箭头,双方互为收发。
De uno a muchos
一个 emisor,多个 receptor。
De muchos a uno
多个 emisor,一个 receptor。
buzón
信箱式中间结构,原文写作 buzon。
canal
通道式中间结构,send(ms,canal)。
mq_send
第三个参数 len ≤ mqsize(发货可以小)。
mq_receive
第三个参数 len ≥ mqsize(收货必须够大)。
mq_send 的 prio
值传递,你告诉队列这条消息多重要。
mq_receive 的 &prio
地址传递,队列把它读到的优先级写回给你。
mq_close
关句柄,队列与消息仍存在,别人还能用。
mq_unlink
按名字删队列,这才是真正移除。
mq_maxmsg
队列能装几条(本例 10)。
mq_msgsize
每条多少字节(本例 sizeof(int))。
mq_flags = 0
阻塞:空则等、满则等。
mq_flags = O_NONBLOCK
不阻塞:立刻返回错误码,自己重试。
mq_curmsgs
只读,告诉你现在有几条。
mq_maxmsg
创建时写,告诉你最多几条。
productor
只看 mq_send,队列满时被阻塞。
consumidor
只看 mq_receive,队列空时被阻塞。
一次 receive 一条
按消息真实到达顺序处理,谁快谁先走。
固定两次 receive
强行「门 1、门 2」交替 → 快门被慢门锁死。