10.1 进程间通信--消息队列

　　进程间通信的分类：

　　　　文件

　　　　文件锁

　　　　管道和匿名管道pipe

　　　　信号

　　　　消息队列

　　　　共享内存

　　　　信号量

　　　　互斥量

　　　　条件变量

　　　　读写锁

　　　　套接字

两个进程同时向管道中写数据，内核要保证它们是原子的，内核按照页做限制。

进程间共享信息的三种方式：一个通过文件系统，一个通过内核，一个在应用空间

 

IPC对象的持续性：

　　随进程持续：一直存在，直到打开的最后一个进程结束。（如pipe和FIFO）

　　随内核持续：一直存在，直到内核自举或者显式删除。（如System V消息队列、共享内存、信号量）

　　随文件系统持续：一直存在，直到显式删除，即使内核自举还存在。（POSIX消息队列、共享内存、信号量（如果是使用映射文件来实现））

 查看系统的IPC对象以及它们的一些属性可以使用ipcs命令，如下：

 

其中key表示键，semid表示这个对象的id，owner表示拥有者。共享内存还有个属性是nattch，表示有多少个人连接上共享内存了。

ipcs -l可以查看IPC对象的一些系统限制：

 

 

消息队列提供了从一个进程向另一个进程发送一块数据的方法

每个数据块都有一个类型，接收者进程接收的数据块可以有不同的类型值

消息队列也有管道一样的不足，就是每个消息的最大长度是有上限的（MSGMAX），每个消息队列的总的字节数是有上限的（MSGMNB），系统上消息队列的总数也有一个上限（MSGMNI）。

管道是基于数据流的，先进先出。

消息队列是有边界的，可以后进先出。

消息队列有如下三个限制：

cat  /proc/sys/kernel/msgmax      最大消息长度限制

cat  /proc/sys/kernel/msgmnb      消息队列总的字节数

cat  /proc/sys/kernel/msgmni        消息条目数

 使用man 2 msgctl可以查看消息队列的一些数据结构：

struct msqid_ds {
struct ipc_perm msg_perm; /* Ownership and permissions */
time_t msg_stime; /* Time of last msgsnd(2) */
time_t msg_rtime; /* Time of last msgrcv(2) */
time_t msg_ctime; /* Time of last change */
unsigned long __msg_cbytes; /* Current number of bytes in
queue (nonstandard) */
msgqnum_t msg_qnum; /* Current number of messages
in queue */
msglen_t msg_qbytes; /* Maximum number of bytes
allowed in queue */
pid_t msg_lspid; /* PID of last msgsnd(2) */
pid_t msg_lrpid; /* PID of last msgrcv(2) */
};

struct ipc_perm {
key_t __key; /* Key supplied to msgget(2) */
uid_t uid; /* Effective UID of owner */
gid_t gid; /* Effective GID of owner */
uid_t cuid; /* Effective UID of creator */
gid_t cgid; /* Effective GID of creator */
unsigned short mode; /* Permissions */
unsigned short __seq; /* Sequence number */
};

消息队列在内核中的表示如下：

msq_ids存储了消息的一些元信息，具体的消息由内核来管理。

消息队列相关的一些API函数：

msgget函数原型如下：

　　int msgget(key_t key,  int  msgflg)

　　功能：用来创建和访问一个消息队列

　　参数：

　　　　key表示某个消息队列的名字

　　　　msgflg：由九个权限标志构成，它们的用法和创建文件时使用的mode模式标志是一样的

　　返回值：成功返回一个非负整数，即该消息队列的标识码；失败返回-1

 编写如下的msgget测试函数：

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

int main()
{
    int msgid;
    
    msgid = msgget(0x1234, 0666);
    if(msgid < 0)
    {
        perror("msgget error");
        exit(0);
    }
    
    return 0;
}

这段程序代表打开一个消息队列，0666代表权限，0代表8进制，执行结果如下：

系统中没有key值为0x1234的消息队列，所以出错返回。我们可以根据errno错误码进行更精确的控制。

我们修改msgget函数的第二个参数，程序如下：

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

int main()
{
    int msgid;
    
    msgid = msgget(0x1234, 0666 | IPC_CREAT);
    if(msgid < 0)
    {
        perror("msgget error");
        exit(0);
    }
    
    printf("create msg queue success
");
    
    return 0;
}

现在的参数表示，如果这个消息队列存在就打开旧的，如果不存在就创建新的。

现在我们的系统中是没有消息队列的，执行结果如下：

使用ipcs查看系统中的消息队列如下：

可以看到确实出现了一个key值为0x1234的消息队列IPC对象。

进一步加参数，如下：

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

int main()
{
    int msgid;
    
    msgid = msgget(0x1234, 0666 | IPC_CREAT | IPC_EXCL);
    if(msgid < 0)
    {
        if(errno == EEXIST)
        {
            printf("msg is exist
");
        }
        perror("msgget error");
        exit(0);
    }
    
    printf("create msg queue success
");
    
    return 0;
}

加上IPC_EXCL表示，如果文件存在，若还要创建（加了IPC_CREAT）则返回错误。单独用IPC_EXCL没有意义。

执行结果如下：

我们验证key取IPC_PRIVATE的情况，如下：

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

int main()
{
    int msgid;
    
    msgid = msgget(IPC_PRIVATE, 0666 );
    if(msgid < 0)
    {
        if(errno == EEXIST)
        {
            printf("msg is exist
");
        }
        perror("msgget error");
        exit(0);
    }
    
    printf("create msg queue success
");
    
    return 0;
}

这时候，flag参数的IPC_CREAT和IPC_EXCL都没有作用了，执行结果如下：

此时创建出来的消息队列的key值为0，多次调用这个函数可以创建出多个key为0的消息队列，如下：

 私有的消息队列只能用在本进程或者和本进程有血缘关系的进程（通过fork创建）。将msgid传给其他没有血缘的进程也不能用。

 创建一个IPC对象的逻辑如下：

msgctl函数：

　　原型：int msgctl(int msqid,  int cmd,  struct  msqid_ds  *buf)

　　参数：

　　　　msqid：由msgget函数返回的消息队列标识码

　　　　cmd：将要采取的动作

　　返回值：成功返回0，失败返回-1

cmd可取的三个值如下：

IPC对象，消息队列是linux负责持久化，我们可以从linux内核中获取消息队列的信息，或者修改消息队列。

msgctl的测试函数如下：

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

int main()
{
    int msgid;
    int ret = 0;
    
    msgid = msgget(0x1234, 0666);
    if(msgid < 0)
    {
        if(errno == EEXIST)
        {
            printf("msg is exist
");
        }
        perror("msgget error");
        exit(0);
    }
    
    printf("msgid = %d
", msgid);
    
    struct msqid_ds buf;
    memset(&buf, 0, sizeof(buf));
    ret = msgctl(msgid, IPC_STAT, &buf);
    
    if(ret == -1)
    {
        perror("msgctl error");
        exit(0);
    }
    
    printf("mode = %o
", buf.msg_perm.mode);
    
    return 0;
}

系统中已经存在一个我们以前创建的消息队列，key为0x1234，msgid为0，执行程序，结果如下：

 msgsnd函数，消息队列的发送函数：

　　原型：int msgsnd(int msqid,  const void* msgp, size_t  msgsz, int  msgflg)

　　参数：

　　　　msgid：由msgget返回的消息队列标识码

　　　　msgp：是一个指针，指针指向准备发送的消息

　　　　msgsz：是msgp指向的消息的长度，这个长度不包含保存消息类型的那个long int长类型

　　　　msgflg：控制着当前消息队列满或到达系统上限时将要发生的事情

　　返回值：成功返回0，失败返回-1

　　msgflg=IPC_NOWAIT表示队列满不等待，返回EAGAIN错误

　　消息结构在两方面受到制约，首先，它必须小于系统规定的上限值；其次，它必须以一个long int长整数开始，接收者将利用这个长整数确定消息的类型

　　消息结构参考形式如下：

struct msgbuf

{

　　long  mtype；

　　char  mtext[1]；

}

测试函数如下：

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

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

int main()
{
    int msgid;
    int ret = 0;
    
    msgid = msgget(0x1234, 0666);
    if(msgid < 0)
    {
        if(errno == EEXIST)
        {
            printf("msg is exist
");
        }
        perror("msgget error");
        exit(0);
    }
    
    printf("msgid = %d
", msgid);
    
    struct msgbuf buf;
    memset(&buf, 0, sizeof(struct msgbuf));
    buf.mtype = 1;
    strcpy(buf.mtext, "1111111222222333333");    
    
    ret = msgsnd(msgid, &buf, 10, IPC_NOWAIT);
    if(ret < 0)
    {
        perror("msgsnd error");
        exit(0);
    }
    
    return 0;
}

消息类型我们定义为1类型，这个是自己选的。系统中已经存在key值为0x1234的消息队列，我们执行完这个函数后，消息就已经写入到了这个消息队列中，我们怎么验证呢？msgctl可以读出消息队列的信息，我们写如下的验证程序：

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

int main()
{
    int msgid;
    int ret = 0;
    
    msgid = msgget(0x1234, 0666);
    if(msgid < 0)
    {
        if(errno == EEXIST)
        {
            printf("msg is exist
");
        }
        perror("msgget error");
        exit(0);
    }
    
    printf("msgid = %d
", msgid);
    
    struct msqid_ds buf;
    memset(&buf, 0, sizeof(buf));
    ret = msgctl(msgid, IPC_STAT, &buf);
    
    if(ret == -1)
    {
        perror("msgctl error");
        exit(0);
    }
    
    printf("mode = %o
", buf.msg_perm.mode);
    printf("bytes in msg queue : %d
", buf.__msg_cbytes);
    printf("msg numbers : %d
", buf.msg_qnum);
    
    return 0;
}

执行结果如下：

这和我们写到消息队列中的消息是吻合的。

 msgrcv接收消息函数：

　　原型：ssize_t  msgrcv(int  msqid,  void *msgp,  size_t  msgsz,  long  msgtyp,  int  msgflg)

　　参数：

　　　　msgid：由msgget函数返回的消息队列标识码

　　　　msgp：是一个指针，指针指向准备接收的消息

　　　　msgsz：是msgp指向的消息的长度，这个长度不含保存消息类型的那个long int长整型

　　　　msgtype：它可以实现接收优先级的简单形式

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

　　返回值：成功返回实际放到接收缓冲区中的字符个数，失败返回-1

msgtype=0  返回队列第一条信息

msgtype>0 返回队列第一条类型等于msgtype的消息

msgtype<0 返回队列第一条类型小于等于msgtype绝对值的消息，并且是满足条件的消息类型最小的消息

msgflg=IPC_NOWAIT，队列没有可读消息时不等待，返回ENOMSG错误。

msgflg=MSG_NOERROR，消息大小超过msgsz时被截断

msgtype>0且msgflg=MSG_EXCEPT，接收类型不等于msgtype的第一条消息。

 上面我们已经将消息写到了消息队列中，这个消息队列由内核维护，现在我们下一个读消息的程序，如下：

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

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

int main()
{
    int msgid;
    int ret = 0;
    
    msgid = msgget(0x1234, 0666);
    if(msgid < 0)
    {
        if(errno == EEXIST)
        {
            printf("msg is exist
");
        }
        perror("msgget error");
        exit(0);
    }
    
    printf("msgid = %d
", msgid);
    
    struct msgbuf buf;
    memset(&buf, 0, sizeof(struct msgbuf));

    ret = msgrcv(msgid, &buf, 1024, 0, IPC_NOWAIT);
    if(ret < 0)
    {
        perror("msgrcv error");
        exit(0);
    }
    
    buf.mtext[ret] = '';
    printf("recv msg : %s
", buf.mtext);
    
    return 0;
}

执行结果如下：

可以看到，读出的消息正是我们写入的。再次执行我们的验证程序（读取消息队列的状态），结果如下：

可以看到，消息已经被我们读走了，现在的队列中已经没有消息了。

综合案例如下：

#include <sys/types.h>
#include <unistd.h>

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <errno.h>

#include <sys/msg.h>

struct msg_buf
{
    long mtype;
    char data[255];
};
 
/* 注意long 和 int 在32bit 和 64bit系统之下是不一样的
struct msg_buf
{
    long mtype;
    char data[255];
};
*/
 
int main()
{
    key_t key;
    int msgid;
    int ret;
    struct msg_buf msgbuf;
    int msgtype =  getpid();

    key=ftok("./msgfile",'a');
    printf("key =[%x]
",key);
    
    printf("sizeof(long):%ld, sizeof(int):%d 
", sizeof(long), sizeof(int));
    
    msgid=msgget(key, IPC_CREAT |IPC_EXCL|0666); //通过文件对应

    if(msgid==-1)
    {
        if (errno == EEXIST)
        {
            printf("EEXIST:.....
");
            key=ftok("./msgfile",'a');
            msgid=msgget(key, IPC_CREAT|0666); //通过文件对应
        }
        else
        {
             printf("create error
");
            perror("msget: 
");
            return -1;
        }
        
    }
    printf("msgid:%d 
", msgid);

       msgbuf.mtype = msgtype; //        getpid();

    printf("getpid(): %d 
", getpid());
    strcpy(msgbuf.data,"test haha");
    ret = msgsnd(msgid,&msgbuf, sizeof(msgbuf.data), IPC_NOWAIT);
    if(ret==-1)
    {
            printf("send message err
");
            perror("senderr");
            return -1;
    }
    sleep(1);

    memset(&msgbuf,0,sizeof(msgbuf));
    
    ret=msgrcv(msgid, &msgbuf, sizeof(msgbuf.data), msgtype, IPC_NOWAIT);
    if(ret==-1)
    {
            printf("recv message err
");
            perror("dd");
            return -1;
    }
    printf("recv msg =[%s]
",msgbuf.data);
 
}

ftok是一个产生key值的函数，消息队列、共享内存、信号量都可以使用这个key。ftok第一个参数是路径，应用中可以将某个路径设置成一个环境变量。应用程序中就可以统一用getenv获取这个环境变量的值，得到路径名，然后再将路径名传给ftok函数。