管道里连续写两次 write,对面读到的是连成一片的字节流,没有任何标记能告诉它这是两条消息。消息队列把"一次发送"变成"一条记录":正文长度由 msgsz 给出,类型由 mtype 给出,内核负责排队、唤醒和类型筛选。
一条消息是带类型的块
每个消息的最大长度受 MSGMAX 限制,一条队列的总字节数受 MSGMNB 限制,系统上队列总数受 MSGMNI 限制。三个默认值随内核版本和发行版调整,用 ipcs -l 或 /proc/sys/kernel/msgmax 一类的入口看本机,别照抄旧数字。

消息结构体不是标准替你定义好的,要自己写:
struct MsgBuf
{
long mtype; /* 必须大于 0 */
char mtext[1024]; /* 正文,长度由 msgsz 给出 */
};mtype 必须是 long,因为内核在 msgp 的偏移 0 处按本机字长读这个类型,再从 msgp + sizeof(long) 开始拷正文。写成 int,64 位下编译器会在 int 和 mtext 之间补 4 个字节,正文起点和内核期待的对不上。课件抄的 struct msgbuf 写成 char mtext[1],那只是"正文跟在类型后面"的最小示意,实际用时要按自己的容量扩。
int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);msgsz 只算正文,不含 mtype。msgflg 传 0 时,队列满了就阻塞;传 IPC_NOWAIT 时不等待,返回 EAGAIN。超过 MSGMAX 返回 EINVAL,内核不会替你截断。
ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp, int msgflg);返回值是实际拷进缓冲区的字节数。msgtyp 决定挑哪条:
msgtyp | 取哪条 |
|---|---|
0 | 队首第一条,不看类型 |
正数 T | 第一条类型正好等于 T 的 |
负数 -T | 类型小于等于 T 的消息里,类型数字最小的那条 |
正数 T 加 MSG_EXCEPT | 第一条类型不等于 T 的 |
负数这一档挑的是"类型最小",不是"最早入队"。把优先级编码进 mtype,数字越小越先被取走,就是靠这条规则。它只做一次线性扫描,队列本身不按类型排序,类型很多时扫描代价会上去。
msgflg 另外两位要记住。MSG_NOERROR 允许"消息比 msgsz 长"时截断并返回;不带它,msgrcv 返回 E2BIG,而且消息原封不动留在队列里。IPC_NOWAIT 在队列里没有匹配消息时返回 ENOMSG,不是 EAGAIN。
发送端的类型必须是正的。msgsnd 不接受 0 或负数;msgrcv 又用 0 和负数表示筛选规则,所以发送端只能用正整数。
msgget 的低 9 位才是权限
int msgget(key_t key, int msgflg);课件写"msgflg 由九个权限标志构成,用法和创建文件时的 mode 一样",只说对了低 9 位。高位的 IPC_CREAT 表示不存在就建,IPC_EXCL 必须和它一起用,表示存在就报 EEXIST;这两个不是权限。队列已存在时,权限位被忽略,直接返回 msqid。
int msgctl(int msqid, int cmd, struct msqid_ds *buf);课件说 cmd "有三个可取值",指的是日常用的三个:

IPC_INFO、MSG_INFO、MSG_STAT、MSG_STAT_ANY 也存在,返回值不是 0:MSG_STAT 返回给定下标对应的队列标识,IPC_INFO 返回内核内部表里最高使用项的下标。IPC_RMID 立刻删除,阻塞在 msgsnd、msgrcv 上的进程收到 EIDRM,之后再用旧 id 是 EINVAL。它不会等消息被取完。
课件抄的 struct msqid_ds 来自内核侧的 /usr/include/linux/msg.h,有两处排版和类型上的问题:
- 前两个成员写成
struct msg msg_first、struct msg msg_last,源码里是struct msg_msg *msg_first、struct msg_msg *msg_last,指针星号丢了。 - 行尾注释
/* first message on queue,unused */的开头/*在抽取时丢了,看起来像半截语句。
用户态 #include <sys/msg.h> 拿到的 msqid_ds 是另一份声明:字节数成员叫 __msg_cbytes,条数和上限用 msgqnum_t、msglen_t(64 位上就是 unsigned long)。把内核头文件里那组 unsigned short 当成用户态字段宽度去 printf,数字会对不上。
内核里的对象分三层:

msg_queue:q_perm权限,q_stime/q_rtime/q_ctime三个时间戳,q_cbytes当前字节数,q_qnum条数,q_qbytes上限,q_lspid/q_lrpid最后收发的进程。msg_msg:m_list挂链表,m_type就是发送方写的mtype,m_ts是正文长度,正文跟在这个头后面。msg_msgseg:正文超过第一块能装的量时,剩余部分切成续片串起来。
msqid_ds 里的 msg_lcbytes、msg_lqbytes 是 32 位兼容层复用的字段,真正的当前字节数在 q_cbytes;ipc_perm 里是 __key、属主和创建者的 uid/gid、mode 与 __seq,和信号量那套共用同一个结构。
队列的生命周期随内核。发送进程退出、接收进程还没起,消息照旧躺在里面。清场:
ipcs -q
ipcrm -q <msqid>服务启动时先 msgget(key, 0) 探测一次,存在就 IPC_RMID 再独占创建,能避开上一轮崩溃留下的队列和旧消息;否则 IPC_CREAT | IPC_EXCL 只会给你一个 EEXIST。
封装的三处越界:拷贝长度、发送长度、结尾补零
课件那层 MsgQueueBase 用 msg_t 装消息,MsgQueueClient 只附着已有队列,MsgQueueServer 用 IPC_CREAT | IPC_EXCL | 0666 创建并在析构时删除。发送和接收分别是:
bool SendMessage(const std::string &in, long type)
{
msg_t msg;
msg.mtype = type;
memset(msg.mtext, 0, sizeof(msg.mtext));
strncpy(msg.mtext, in.c_str(), in.size());
int n = ::msgsnd(_msgid, &msg, in.size(), 0);
return n >= 0;
}
bool RecvMessage(std::string *out, long type)
{
msg_t msg;
int n = ::msgrcv(_msgid, &msg, SIZE, type, 0);
if (n < 0)
return false;
msg.mtext[n] = 0;
*out = msg.mtext;
return true;
}三处都在容量边界外:
strncpy的第三个参数是"最多拷多少字节",这里传的是来源长度,不是目标容量。in.size()超过sizeof(msg.mtext)时就是一次写越界。msgsnd的msgsz也跟着来源长度走。如果前面被截断,实际写进去的字节数和msgsz对不上,发出去的是栈上的越界内容。msgrcv的msgsz传SIZE,正好等于数组容量。收到的消息刚好SIZE字节时,n == SIZE,mtext[SIZE] = 0写在数组末尾之外。
改法是先把长度夹到容量减一,再让 msgsz 等于实际拷进去的字节数:
static int Send(int msqid, const char *text, long type)
{
struct
{
long mtype;
char mtext[1024];
} msg;
size_t n = strlen(text);
if (n > sizeof(msg.mtext) - 1)
n = sizeof(msg.mtext) - 1;
memset(&msg, 0, sizeof(msg));
msg.mtype = type;
memcpy(msg.mtext, text, n);
return msgsnd(msqid, &msg, n, 0);
}接收侧把 msgsz 传 sizeof(msg.mtext) - 1,这样返回值严格小于容量,mtext[n] = '\0' 才安全;把内容交给 std::string 时用返回值当长度,不要用 strlen,正文里完全可能有 \0。
strncpy 的语义是"最多拷 n 个字节,不够就补零",正好拷满 n 个时不留结尾零,n 大于源串时又把整个目标填满零,两头都别扭;自己算 min(来源长度, 容量 - 1) 再 memcpy,意图清楚。
封装还有两处不属于越界、但会在第一次部署时咬人的地方。GET_MSGQUEUE 定义成裸的 IPC_CREAT,客户端先启动就会把队列建成 mode 0000,之后自己 msgsnd 也是 EACCES。服务端对象的析构里直接 IPC_RMID,如果服务端先退出,客户端下一条 msgsnd 就是 EIDRM。这两点和信号量那篇的所有权问题同源。
课件附带的 Client 和 Server 两个 main 把协议跑通:客户端以类型 CLIENT 发一条 "hello bite",服务端以类型 CLIENT 收并打印;SERVER 和 CLIENT 只是两个宏定义的消息类型,发送方和接收方必须用同一个数字。
一条队列同时收发,类型不分开就会摘到自己的回执
课件结论说"消息队列支持全双工通信"。准确说法是:同一个队列上,发送和接收互不阻塞,一个进程可以边发边收。但两个方向的报文混在一条链表里,只能靠 mtype 区分。服务器用类型 1 发响应、又用类型 1 收请求,完全可能摘到自己刚发出去的回执。要么收发各一个队列、两个 key,要么给两个方向分配不重叠的类型段。
三个处理者串成一条责任链
基础版本只做"客户端发、服务端收"。新需求加了三步:发送内容要拼上时间戳和进程号,服务端要把内容追加到日志文件,文件行数超过阈值要切片打包。把三步写死成三个函数调用也能跑,但开关全在代码里,测试只想验证格式化时得改源码。
责任链(Chain of Responsibility)把"这一步做不做"和"下一步是谁"从处理逻辑里搬出去:每个处理者只实现自己那一步,处理完把请求交给 _next_handler;客户端只认识链头。

课件里 HandlerText 是基类,保存 _next_handler 和 _enable,提供 SetNextHandler、Enable、DisEnable、IsEnable,Execute 是纯虚函数。三个派生类分别是:
HandlerTextFormat:用stringstream拼time(nullptr) - getpid() - info,把结果写回info。HandlerTextSaveFile:构造时确保./tmp/存在,Execute里以追加方式打开./tmp/test.log并写入。HandlerTextBackupFile:数一遍日志行数,超过maxline就fork出子进程,chdir到目录、rename旧文件、execlp("tar", "tar", "czf", 包名, 文件名, nullptr)打包,父进程waitpid后删掉原文件。
HandlerEntry 在构造时把三个对象建好并链成 format → save → backup,EnableHandler 按三个布尔值分别开关,Run 从链头进入。
课件的实现有两个结构问题。每个派生类的 Execute 都抄了一遍"如果 _next_handler 存在就调用它",第四种处理者忘了抄,链路就断,编译器不会提醒。HandlerTextSaveFile::Execute 在 out.is_open() 失败时直接 return,后面的备份节点不再执行;备份节点读不到文件时也一样。这跟"处理完必须把请求传给下一环"的约定相反。
把不变的分发逻辑提到基类的非虚入口,派生类只写自己那一步:
#include <memory>
#include <string>
class Handler
{
public:
virtual ~Handler() = default;
void SetNext(std::shared_ptr<Handler> next) { _next = std::move(next); }
void Enable() { _enabled = true; }
void Disable() { _enabled = false; }
void Handle(std::string &info)
{
if (_enabled)
Process(info);
if (_next)
_next->Handle(info);
}
protected:
virtual void Process(std::string &info) = 0;
private:
std::shared_ptr<Handler> _next;
bool _enabled = true;
};失败要不要中断链路是语义问题,不是实现问题。想"失败即停"就在 Process 返回布尔值并由 Handle 判断;想"记录后继续"就只打印错误。两种都行,含糊不行。
execlp 那条注释值得保留:它是变参函数,参数列表必须以空指针结尾,少了这个结尾,tar 会去读栈上的垃圾。fork 出的子进程改了工作目录,父进程不受影响;rename 之后原路径空出来,下一次写入会重新创建文件,所以打包可以并行于后续日志。
责任链也不是所有流程都适合。三个步骤有严格数据依赖、必须无条件按序执行时,三个函数调用更直白;节点数量会随配置涨到几十个时,插件表加循环比一根硬编码的链更好维护。这个模式解决的是"流程归属",不是"看起来高级"。
还没有评论 — 第一条由你来留。