进程间通信方式（二）：System V 消息队列

一、概念

        消息队列又叫做报文队列，是一条由消息连接而成的链式队列，它保存在内核中，并使用消息队列标识符进行标识。
        消息队列提供了一种从一个进程向另一个进程发送一个数据块的方法，并且每个数据块都被认为含有一个类型，接收进程可以独立地接收含有不同类型的数据块。对消息队列有写权限的进程可以向消息队列中按照一定的规则添加新消息，对消息队列有读权限的进程则可以从消息队列中读走消息。
        目前主要有两种类型的消息队列：System V 消息队列 和 POSIX 消息队列，本文仅对前者展开讲述。

二、特点

1. 消息队列中的每一个消息都具有特定的格式以及特定的优先级；

2. 消息队列在内核中使用特定的标识符进行标识，从而保证了消息队列在整个系统中的唯一性，所以可以通过标识符来访问消息队列；

3. 消息队列具有一定的 FIFO（先入先出）特性，但是它也可以实现消息的随机查询，比 FIFO 具有更大的优势；

4. System V 消息队列是随内核持续的，只有在内核重启或者显式删除一个消息队列时，该消息队列才会被真正删除；

5. 在 Linux 操作系统中，消息队列有如下限制：

   （1）MSGMAX：每个消息的字节数上限
   （2）MSGMNI：系统中消息队列的总条数上限
   （3）MSGMNB：每个消息队列的总字节数上限

   以上信息可通过下面两种方法查看：
   
   【方法一】：通过 ipcs -l 命令查看
   
   

   【方法二】：查看系统内核信息
   
   

三、IPC 对象数据结构

        内核为每个 IPC 对象维护一个数据结构，该结构说明了 IPC 对象的权限和所有者，详细信息可参阅文件 /usr/include/linux/ipc.h 。

struct ipc_perm
{
	__kernel_key_t  key;   /* Key supplied to ***get(2) */
	__kernel_uid_t  uid;   /* Effective UID of owner */
	__kernel_gid_t  gid;   /* Effective GID of owner */
	__kernel_uid_t  cuid;  /* Effective UID of creator */
	__kernel_gid_t  cgid;  /* Effective GID of creator */
	__kernel_mode_t mode;  /* Permissions  */
	unsigned short  seq;   /* Sequence number */
};

        结构中的 mode 类似于创建文件时使用的 mode，但是没有执行权限，具体取值如下：

操作者	只读权限	只写权限	可读可写权限
所有者 (owner)	0400	0200	0600
用户组 (group)	0040	0020	0060
其他 (others)	0004	0002	0006

        当调用 IPC 对象的创建函数（msgget、semget、shmget ）时，会对 ipc_perm 结构体中的每一项赋值，在后续的操作中若要修改这几项则调用相应的控制函数（msgctl、semctl、shmctl），需要注意的是，只有超级用户或者创建 IPC 对象的进程才有权改变 ipc_perm 结构的值。

四、消息队列数据结构

        在内核中，每个消息队列都有一个 msqid_ds 结构与其关联，该结构说明了消息队列的一些状态信息等等，详细信息可参阅文件 /usr/include/linux/msg.h 。

struct msqid_ds
{    
    struct ipc_perm msg_perm;   /* Ownership and permissions */
    struct msg *msg_first;      /* first message on queue,unused  */    
    struct msg *msg_last;       /* last message in queue,unused */    
    __kernel_time_t msg_stime;  /* last msgsnd time */    
    __kernel_time_t msg_rtime;  /* last msgrcv time */    
    __kernel_time_t msg_ctime;  /* last change time */    
    unsigned long  msg_lcbytes; /* Reuse junk fields for 32 bit */    
    unsigned long  msg_lqbytes; /* ditto */    
    unsigned short msg_cbytes;  /* current number of bytes on queue */    
    unsigned short msg_qnum;    /* number of messages in queue */    
    unsigned short msg_qbytes;  /* max number of bytes on queue */    
    __kernel_ipc_pid_t msg_lspid;   /* pid of last msgsnd */    
    __kernel_ipc_pid_t msg_lrpid;   /* last receive pid */    
};

五、消息队列在内核中的表示

        在前面，我们说过消息队列是一条由消息连接而成的链式队列，所以也可以说每一个消息都是队列中的一个节点，而每个节点的结构类似于下面这样：

struct msg
{
    Type msg_type;
    Length msg_len;
    Data msg_data;
    struct msg *next;
}

        假设现在有一个含有三个消息的消息队列，这些消息的类型分别为 10、20 和 30，长度分别为1字节、2字节和3字节，那么该消息队列在内核中将以如下图所示的结构来表示。

        从上图来看，系统中的每一个消息队列都有一个唯一的标识符，并且都由一个 msqid_ds 结构来表示，其中 msqid_ds.msg_first 和 msqid_ds.msg_last 分别指向这个链式队列的头部和尾部。
        当发送一个消息到该消息队列时，先把发送的消息构造成一个 msg 结构对象，然后再将该对象添加到由 msqid_ds.msg_first 和 msqid_ds.msg_last 维护的队列中去；而当从消息队列中接收一个消息时，先根据消息的类型 msg_type 有选择地从队列中遵照 FIFO 原则读取特定类型的消息，再将该消息从队列中删除并修改 msqid_ds 结构对象的数据。

六、消息队列相关函数

1. msgget

• 【头文件】：#include <sys/types.h>、#include <sys/ipc.h>、#include <sys/msg.h>
• 【函数原型】：int msgget(key_t key, int msgflg);
• 【功能】：创建或打开一个消息队列，这里创建的消息队列数量会受到系统消息队列数量的限制
• 【参数】：

     （1）key：消息队列的键值，其中有一个特殊值 IPC_PRIVATE，它用于创建当前进程的私有消息队列
     （2）msgflg：权限标志位，由两部分组成，一部分为IPC对象存取权限（含义同 ipc_perm 中的 mode），另一部分为IPC对象创建模式标志（IPC_CREAT、IPC_EXCL），一般会将这两部分进行 | 运算，从而完成对IPC对象创建的管理

• 【返回值】：成功返回一个消息队列标识符（非负整数）；失败则返回 -1，并将 errno 设置为错误标识符

创建或打开一个 IPC 对象的逻辑流程图

【示例】：演示 IPC_CREAT|IPC_EXCL 的使用效果
【代码】：

#include <stdio.h>    
#include <sys/types.h>    
#include <sys/ipc.h>    
#include <sys/msg.h>    
#include <errno.h>    
         
int main()
{    
    extern int errno;                                                                                                                                 
    int msqid = msgget(0x123, 0644|IPC_CREAT|IPC_EXCL);    
    if(msqid == -1) {    
        printf("msgget error!\n");    
        printf("errno: %d\n", errno);    
        perror("result");    
        return -1;    
    }    
    printf("msgget success!\n");    
    return 0;    
}

【执行结果】：


【分析】：
        从执行结果来看，当我们第一次运行程序时，成功创建了消息队列。但是，当第二次运行程序后，发现创建失败，errno 被置为17，也就是 EEXIST，错误信息为 File exists，出现这样的结果是因为我们在第一次程序运行后，该消息队列就已经在系统中存在了，而我们在创建消息队列又使用了 IPC_EXCL，这才导致 msgget 出错返回。

2. msgctl

• 【头文件】：#include <sys/types.h>、#include <sys/ipc.h>、#include <sys/msg.h>
• 【函数原型】：int msgctl(int msqid, int cmd, struct msqid_ds *buf);
• 【功能】：获取或设置消息队列的有关信息
• 【参数】：

     （1）msqid：消息队列标识符
     （2）cmd：对消息队列要采取的动作

取值	说明
IPC_STAT	读取消息队列的 msqid_ds 结构信息，并将其存储在 buf 指定的地址空间中
IPC_SET	设置消息队列的 msqid_ds 结构信息，这些取值来自于 buf 指定地址空间中的参数（需要足够权限）
IPC_RMID	将消息队列从内核中删除

     （3）buf：描述消息队列 msqid_ds 数据结构的变量

• 【返回值】：成功返回 0；失败则返回 -1，并将errno设置为错误标识符

【示例】：演示 IPC_STAT 的使用效果
【代码】：

#include <stdio.h>    
#include <sys/types.h>    
#include <sys/ipc.h>    
#include <sys/msg.h>    
         
int main() {    
    int msqid = msgget(0x123, 0644|IPC_CREAT);                                                                                                        
    if(msqid == -1) {    
        printf("msgget error!\n");    
        return -1;    
    }    
         
    struct msqid_ds buf;    
    if (msgctl(msqid, IPC_STAT, &buf) == -1) {    
        printf("msgctl error!\n");    
        return -1;    
    }    
         
    printf("buf.msg_perm.mode = %o\n", buf.msg_perm.mode);    
    printf("buf.msg_perm.__key = %x\n", buf.msg_perm.__key);    
         
    return 0;    
}

【执行结果】：

3. msgsnd

• 【头文件】：#include <sys/types.h>、#include <sys/ipc.h>、#include <sys/msg.h>
• 【函数原型】：int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);
• 【功能】：将指定消息添加到已打开消息队列的队尾
• 【参数】：

     （1）msqid：消息队列标识符
     （2）msgp：消息结构指针，指向准备发送的消息

消息结构如下：

struct msgbuf {    
    long mtype; //type of message，必须大于0，msgrcv 将利用这个长整数确定消息的类型
    char mtext[1]; //message text，可以设定为更多的字节数但必须小于 MSGMAX
};

     （3）msgsz：msgp 所指向消息的正文长度，这个长度不包含保存消息类型的那个 long int 型整数
     （4）msgflg：控制着当前消息队列满或到达系统上限时将要发生的事情

取值	说明
IPC_NOWAIT	若消息无法立即发送（比如当前队列已满），那么函数会立即返回，并把 errno 置为 EAGAIN
0	函数进入阻塞状态，直到发送成功为止

• 【返回值】：成功返回 0；失败则返回 -1，并将errno设置为错误标识符

4. msgrcv

• 【头文件】：#include <sys/types.h>、#include <sys/ipc.h>、#include <sys/msg.h>
• 【函数原型】：ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp, int msgflg);
• 【功能】：从消息队列中取走一条消息，与 FIFO 不同的是，这里可以取走指定类型的消息
• 【参数】：

     （1）msqid：消息队列标识符
     （2）msgp：消息结构指针，指向消息接收缓冲区
     （3）msgsz：msgp 所指向消息的正文长度，这个长度不包含保存消息类型的那个 long int 型整数
     （4）msgtyp：指定接收消息的类型

取值	说明
msgtyp>0	返回消息队列中第一条类型为 msgtyp 的消息
msgtyp=0	返回消息队列中的第一条消息
msgtyp<0	返回消息队列中一条类型小于或等于 msgtyp 绝对值的消息，并且在满足条件的所有消息中其又是类型最小的消息

     （5）msgflg：控制着队列中没有相应类型的消息可供接收时将要发生的事

取值	说明
MSG_NOERROR	若返回的消息大小超过 msgsz，那么消息就会截短到 msgsz 字节，并且不会报错
IPC_NOWAIT	若在消息队列中没有相应类型的消息可以接受，那么函数会立即返回，并把 error 置为 ENOMSG
0	函数进入阻塞状态，直到接收到一条相应类型的消息为止

• 【返回值】：成功返回实际放到接收缓冲区中的字节数；失败则返回 -1，并将errno设置为错误标识符

七、综合应用

【示例】：利用消息队列实现服务端与客户端通信
【代码】：

/*
 * 服务端 server.c
 */

#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>

#define PATHNAME "."
#define PROJ_ID 0x1234

#define SERVER_TYPE 1
#define CLIENT_TYPE 2

struct msgbuf {
    long mtype;
    char mtext[1024];
};

int main() {
    //创建消息队列键值
    key_t key = ftok(PATHNAME, PROJ_ID);
    if(key < 0) {
        perror("ftok error");
        return -1;
    }

    //创建消息队列
    int msqid = msgget(key, 0644|IPC_CREAT|IPC_EXCL);
    if(msqid < 0) {
        perror("msgget error");
        return -1;
    }

    int count = 2; //通信两次
    while(count--) {
        //从消息队列中接收信息
        struct msgbuf rcv_buf;
        if(msgrcv(msqid, (void*)&rcv_buf, sizeof(rcv_buf.mtext), CLIENT_TYPE, 0) < 0) {
            perror("msgrcv error");
            break;
        }
        printf("> Client: %s", rcv_buf.mtext);

        //向消息队列中添加消息
        printf("Please input: ");
        fflush(stdout);
        char text[1024] = {0};
        ssize_t size = read(0, text, 1023);
        if(size < 0) {
            perror("read error");
            break;
        }
        else {
            text[size] = '\0';
            struct msgbuf snd_buf;
            snd_buf.mtype = SERVER_TYPE;
            strcpy(snd_buf.mtext, text);
            if(msgsnd(msqid, (void*)&snd_buf, sizeof(snd_buf.mtext), 0) < 0) {
                perror("msgsnd error");
                break;
            }
            printf("After sending, wait for receiving...\n");
        }					 
    }

    // 删除消息队列
    if(msgctl(msqid, IPC_RMID, NULL) < 0) {
        perror("msgctl error");
        return -1;
    }

    return 0;
}

/*
 * 客户端 client.c
 */

#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>

#define PATHNAME "."
#define PROJ_ID 0x1234

#define SERVER_TYPE 1
#define CLIENT_TYPE 2

struct msgbuf {
	long mtype;
	char mtext[1024];
};

int main() {
    //创建消息队列键值
	key_t key = ftok(PATHNAME, PROJ_ID);
	if(key < 0) {
		perror("ftok error");
		return -1;
	}
	
	//打开消息队列
	int msqid = msgget(key, 0644|IPC_CREAT);
	if(msqid < 0) {
		perror("msgget error");
		return -1;
	}

    int count = 2; //通信两次
	while(count--) {
		//向消息队列中添加消息
		printf("Please input：");
		fflush(stdout);
	    char text[1024] = {0};
		ssize_t size = read(0, text, 1023);
		if(size < 0) {
			perror("read error");
			break;
		}
		else {
			text[size] = '\0';
			struct msgbuf snd_buf;
			snd_buf.mtype = CLIENT_TYPE;
			strcpy(snd_buf.mtext, text);
			if(msgsnd(msqid, (void*)&snd_buf, sizeof(snd_buf.mtext), 0) < 0) {
				perror("msgsnd error");
				break;
			}
			printf("After sending, wait for receiving...\n");
		}

		//从消息队列中接收信息
		struct msgbuf rcv_buf;
		if(msgrcv(msqid, (void*)&rcv_buf, sizeof(rcv_buf.mtext), SERVER_TYPE, 0) < 0) {
			perror("msgrcv error");
			break;
		}
		printf("> Server：%s", rcv_buf.mtext);
	}

	return 0;
}

【执行结果】：

【注】：本文参见 详解 System V 消息队列

【附】：

• 消息队列相关函数 ftok 详解
• Posix 消息队列
• Linux 中 System V、BSD、Posix 的概念