进程间通信之消息队列

消息队列：

消息队列本质上是提供了一种从一个进程向另一个进程发送数据快的方法。每个数据快都被认为是有一个类型，接受者进程接收的数据块可以有不同的类型值。

消息队列和管道的区别：

(1)、消息队列是基于消息的，而管道是基于字节流的，且消息队列的读取不一定是先进先出的。

(2)、消息队列的生命周期是随内核的(不随进程的结束而结束)，而管道的生命周期是随进程的。

(3)、消息队列与命名管道有一样的不足，就是每个消息的最大长度是有上限的(MSGMAX)，每个消息队列的总的字节数是有上限的(MSGMNB)，系统上的消息队列的总数也有一个上限(MSGMNI)。

                 

IPC对象的数据结构：

内核为每个IPC对象维护了一个数据结构(/usr/include/linux/ipc.h)

struct ipc_perm
{
        __kernel_key_t  key;//端口号
        __kernel_uid_t  uid;//所有者的用户ID
        __kernel_gid_t  gid;//所有者组ID
        __kernel_uid_t  cuid;//创建者的用户ID
        __kernel_gid_t  cgid;//创建者的组ID
        __kernel_mode_t mode; //访问模式
        unsigned short  seq;//顺序值
};

消息队列，共享内存和信号量都有这样一个共同的数据结构。

消息队列的结构(/usr/include/linux/msg.h)

struct msqid_ds {
        struct ipc_perm msg_perm;    /* IPC对象结构体 */
        struct msg *msg_first;       /*消息队列头指针*/
        struct msg *msg_last;        /*消息队列尾指针*/
        __kernel_time_t msg_stime;   /*最后一次插入消息队列消息的时间*/
        __kernel_time_t msg_rtime;   /*最后一次接收消息即删除队列中一个消息的时间*/
        __kernel_time_t msg_ctime;   /* 最后修改队列的时间*/
        unsigned long  msg_lcbytes;  /* Reuse junk fields for 32 bit */
        unsigned long  msg_lqbytes;  /* ditto */
        unsigned short msg_cbytes;   /*队列上所有消息总的字节数 */
        unsigned short msg_qnum;     /*在当前队列上消息的个数 */
        unsigned short msg_qbytes;   /* 队列最大的字节数 */
        __kernel_ipc_pid_t msg_lspid;/* 发送最后一条消息的进程的pid */
        __kernel_ipc_pid_t msg_lrpid;/* 接收最后一条消息的进程的pid */
};

可以看到第一个条目就是IPC结构体，即是公有的，后面的都是消息队列私有的成员。消息队列是用链表实现的。

构建消息队列的接口：

1、创建新消息队列或取得已存在消息队列

int msgget(key_t key, int msgflg);

参数：

key：可以认为是一个端口号，也可以由函数ftok生成

msgflg：

IPC_CREAT：如果IPC不存在，则创建一个IPC资源，否则打开操作。

IPC_EXCL：只有在共享内存不存在的时候，新的共享内存才建立，否则就产生错位。如何单独使用IPC_CREAT，msgget()函数要么返回一个已经存在的共享内存的操作符，要么返回一个新建的内存的标识符。

如果IPC_CREAT和IPC_EXCL标志一起使用，msgget()将返回一个新建的IPC标识符；如果该IPC资源已存在，或者返回-1。

IPC_EXEL标志本身并没有太大的意义，但是和IPC_CREAT标志一起使用可以用来保证所得的对象是新建的，而不是打开已有的对象。

2、向队列读/写消息

int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);
ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp, int msgflg);

参数：

msgid：消息队列的标识码

msgp：指向消息缓冲区的指针，此位置用来暂时存储发送和接收的消息，是一个用户可以定义的通用结构，形态如下：

long msgstru
{
     long mtype;//大于0
     char mtext[用户指定大小];//主要通过这个数组来暂时存储发送和接受的消息   
};

msgsz：消息的大小。

msgtyp：从消息队列内读取的消息形态。如果值为零，则表示消息队列中的所有消息都会被读取。

msgflg：用来指明核心程序在队列没有数据的情况下所应采取的行动。如果msgflg和常数IPC_NOWAIT合用，则在

msgsnd()执行时若是消息队列已满，则msgsnd()将不会阻塞，而会立即返回-1，如果执行的是msgrcv()，则在消息队

列呈空时，不做等待马上返回-1，并设定错误码为ENOMSG。当msgflg为0时，msgsnd()及msgrcv()在队列呈满或呈

空的情形时，采取阻塞等待的处理模式。

3、设置消息队列属性

int msgctl ( int msgqid, int cmd, struct msqid_ds *buf );

参数：

msgctl 系统调用对 msgqid 标识的消息队列执行 cmd 操作，系统定义了 3 种 cmd 操作： IPC_STAT , IPC_SET , IPC_RMID

IPC_STAT : 该命令用来获取消息队列对应的 msqid_ds 数据结构，并将其保存到 buf 指定的地址空间。

IPC_SET : 该命令用来设置消息队列的属性，要设置的属性存储在buf中。 

IPC_RMID : 从内核中删除 msqid 标识的消息队列。

Key_t键

System V IPC使用key_t值作为它们的名字，在 Readhat linux(后续验证默认都在该平台下)下key_t被定义为int类型。

ftok函数

key_t ftok(const char *pathname, int proj_id);

参数 [pathname]：通常是跟本应用用关的目录。

参数 [proj_id]：指的是本应用所用到的IPC的一个序列号，成功返回IPC键，失败返回-1。

注：两进程如在pathname和proj_id上达成一致（或约定好），双方就都能够通过调用ftok函数得到同一个IPC键。

pathname的实现是组合了三个键，分别是：

(1)、pathname所在文件系统的信息（stat结构的st_dev成员）。

(2)、pathname在本文件系统内的索引节点号（stat结构的st_ino成员）。

(3)、id的低序8位（不能为0）。

ftok调用返回的整数IPC键由 proj_id的低序8位，st_dev成员的低序8位，st_info的低序16位组合而成。

不能保证两个不同的路径名与同一个proj_id的组合产生不同的键，因为上面所列的三个条目（文件系统标识符、索引节点、proj_id）中的信息位数可能大于一个整数的信息位数。

模拟实现代码如下

//comm.h
#ifndef _COMM_H
#define _COMM_H
#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <string.h>
#define PATHNAME "."
#define PROJ_ID 0x6666
#define SERVER_TYPE 1
#define CLIENT_TYPE 2
struct msgbuf
{
    long mtype;
    char mtext[1024];
};
int createMsgQueue();
int getMsgQueue();
int destroyMstQueue(int msgid);
int senMsg(int msgid, int who, char* msg);
int recvMsg(int msgid, int recvType, char out[]);
#endif

//comm.c
#include "comm.h"
static int commMsgQueue(int flags)
{
    key_t _key = ftok(PATHNAME, PROJ_ID);
    if(_key < 0)
    {
        perror("fotk");
        return 1;
    }
    int msgid = msgget(_key, flags);
    if(msgid < 0)
    {
        perror("msgget");
    }
    return msgid;
}

int createMsgQueue()
{
    return commMsgQueue(IPC_CREAT|IPC_EXCL|0666);
}
int getMsgQueue()
{
    return commMsgQueue(IPC_CREAT);
}

int destroyMsgQueue(int msgid)
{
    if(msgctl(msgid, IPC_RMID, NULL) < 0)
    {
        perror("msgctl");
        return -1;
    }
    return 0;
}

int sendMsg(int msgid, int who, char* msg)
{
    struct msgbuf buf;
    buf.mtype = who;
    strcpy(buf.mtext, msg);
    if(msgsnd(msgid, (void*)&buf, sizeof(buf.mtext), 0) < 0)
    {
        perror("msgsnd");
        return -1;
    }
    return 0;
}

int recvMsg(int msgid, int recvType, char out[])
{
    struct msgbuf buf;
    if(msgrcv(msgid, (void*)&buf, sizeof(buf.mtext), recvType, 0) < 0)
    {
        perror("msgrv");
        return -1;
    }
    strcpy(out, buf.mtext);
    return 0;
}

//server.c
#include "comm.h"
int main()
{
    int msgid = getMsgQueue();
    char buf[1024];
    while(1)
    {
        buf[0] = 0;
        printf("Please Enter# ");
        fflush(stdout);
        ssize_t s = read(0, buf, sizeof(buf));
        if(s > 0)
        {
            buf[s-1] = 0;
            sendMsg(msgid, CLIENT_TYPE, buf);
            //printf("send done, wait recv...\n");
        }
        recvMsg(msgid, SERVER_TYPE, buf);
        printf("server# %s\n", buf);
    }
    return 0;
}

//client.c
#include "comm.h"
int main()
{
    int msgid = createMsgQueue();
    char buf[1024];
    while(1)
    {
        buf[0] = 0;
        recvMsg(msgid, CLIENT_TYPE, buf);
        printf("client# %s\n", buf);
        printf("Please Enter# ");
        fflush(stdout);
        ssize_t s = read(0, buf, sizeof(buf));
        if(s > 0)
        {
            buf[s-1] = 0;
            sendMsg(msgid, SERVER_TYPE, buf);
            //printf("send done, wait recv...\n");
        }
    }
    destroyMsgQueue(msgid);
    return 0;
}

在linux下查看消息队列ipcs -q， 而删除消息队列为ipcrm -q msgid
运行结果和实验代码