管道里连续写两次 write,对面读到的是连成一片的字节流,没有任何标记能告诉它这是两条消息。消息队列把"一次发送"变成"一条记录":正文长度由 msgsz 给出,类型由 mtype 给出,内核负责排队、唤醒和类型筛选。

一条消息是带类型的块

每个消息的最大长度受 MSGMAX 限制,一条队列的总字节数受 MSGMNB 限制,系统上队列总数受 MSGMNI 限制。三个默认值随内核版本和发行版调整,用 ipcs -l 或 /proc/sys/kernel/msgmax 一类的入口看本机,别照抄旧数字。

消息队列的通信形式:进程 1、进程 2 在用户态各自收发,消息带着类型沉进内核队列;接收方可以按类型挑,不必按入队顺序取

消息结构体不是标准替你定义好的,要自己写:

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 "有三个可取值",指的是日常用的三个:

msgctl 的三个常用命令:IPC_STAT 把队列的当前状态读进 msqid_ds,IPC_SET 在权限足够时改 msg_perm 和 msg_qbytes,IPC_RMID 直接删队列

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_messages 链表,每条消息是 msg_msg 头加正文;正文超过第一块容量时用 msg_msgseg 续接

  • 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;客户端只认识链头。

责任链的类结构:Client 只持有链头,Handler 自己保存 successor,handleRequest 处理完再把请求交给下一环,派生类只负责自己那一步

课件里 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 之后原路径空出来,下一次写入会重新创建文件,所以打包可以并行于后续日志。

责任链也不是所有流程都适合。三个步骤有严格数据依赖、必须无条件按序执行时,三个函数调用更直白;节点数量会随配置涨到几十个时,插件表加循环比一根硬编码的链更好维护。这个模式解决的是"流程归属",不是"看起来高级"。