System V 消息队列 实例

前言：

　　消息队列是消息的链接表，存放在内核中，并由消息队列标识符标识。我们将称消息队列为 “队列”，其标识符为“队列I D”。msgget创建一个新队列或打开一个存在的队列; msgsnd向队列末端添加一条新消息; msgrcv从队列中取消息, 获取消息是不一定遵循先进先出的, 也可以按消息的类型字段取消息.

　　消息队列提供了一种从一个进程向另一个进程发送一个数据块的方法。  每个数据块都被认为含有一个类型，接收进程可以独立地接收含有不同类型的数据结构。我们可以通过发送消息来避免命名管道的同步和阻塞问题。但是消息队列与命名管道一样，每个数据块都有一个最大长度的限制。

函数：

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

原型：int msgget(key_t key, int msgflg);

参数：

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

     msgflg：IPC_PRIVATE:创建一个该进程独占的消息队列，其它进程不能访问该消息队列

　　　　　　IPC_CREAT:若消息队列不存在，创建一个新的消息队列，若消息队列存在，返回存在的消息队列

　　　　　　IPC_CREAT | IPC_EXCL: IPC_EXCL标志本身没有多大意义，与IPC_CREAT一起使用，保证只创建新的消息队列，若对应key的消息队列已经存在，则返回错误

　　　　　　IPC_NOWAIT:小队列以非阻塞的方式获取（若不能获取，立即返回错误）

1.1 消息队列Key的获取：

        在程序中若要使用消息队列，必须要能知道消息队列key,因为应用进程无法直接访问内核消息队列中的数据结构，因此需要一个消息队列的标识，让应用进程知道当前操作的是哪个消息队列，同时也要保证每个消息队列key值的唯一性

　　a.通过ftok函数获取

　　key_t key;

　　key=ftok(".","a")

      该函数通过一个路径名称映射出一个消息队列key(我的理解是使用路径映射的方式比较容易获取一个唯一的消息队列key)

　　b.直接定义key:

　　#define MSG_KEY      123456

　　自定义key的方式要注意避免消息队列的重复。

2.向队列读/写消息

原型：

msgrcv从队列中取用消息：ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp, int msgflg);

msgsnd将数据放到消息队列中：int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);

参数：

     msqid：消息队列的标识码

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

struct msgstru{

    long mtype; //大于0

    char mtext[512];

};

     msgsz：消息的大小。

     msgtyp：从消息队列内读取的消息形态。如果msgtype为0，就获取队列中的第一个消息。如果它的值大于零，将获取具有相同消息类型的第一个信息，特指接收哪一类型的消息。如果它小于零，就获取类型等于或小于msgtype的绝对值的第一个消息。

　　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 标识的消息队列。

实例：

发送端创建消息队列，并通过终端读取消息类型和消息内容。

接收端，根据不同的消息类型，判断是否是本进程要接收的消息。

消息发送端：send.c  

/*send.c*/                                                                        
#include <stdio.h>                                                                
#include <sys/types.h>                                                            
#include <sys/ipc.h>                                                              
#include <sys/msg.h>                                                              
#include <errno.h>                                                                
#include <stdlib.h>
                                                                                  
#define MSGKEY 1024                                                               
                                                                                  
struct msgstru                                                                    
{                                                                                 
   long msgtype;                                                                  
   char msgtext[2048];                                                            
};                                                                                
                                                                                  
main()                                                                            
{                                                                                 
  struct msgstru msgs;                                                            
  int msg_type;                                                                   
  char str[256];                                                                  
  int ret_value;                                                                  
  int msqid;                                                                      
                                                                                  
  msqid=msgget(MSGKEY,IPC_EXCL);  /*检查消息队列是否存在*/                        
  if(msqid < 0){                                                                  
    msqid = msgget(MSGKEY,IPC_CREAT|0666);/*创建消息队列*/                        
    if(msqid <0){                                                                 
    printf("failed to create msq | errno=%d [%s]
",errno,(char *)strerror(errno));       
    exit(-1);                                                                     
    }                                                                             
  }                                                                               
                                                                                  
  while (1){                                                                      
    printf("input message type(end:0):");                                         
    scanf("%d",&msg_type);                                                        
    if (msg_type == 0)                                                            
       break;                                                                     
    printf("input message to be sent:");                                          
    scanf ("%s",str);                                                             
    msgs.msgtype = msg_type;                                                      
    strcpy(msgs.msgtext, str);                                                    
    /* 发送消息队列 */                                                            
    ret_value = msgsnd(msqid,&msgs,sizeof(struct msgstru),IPC_NOWAIT);            
    if ( ret_value < 0 ) {                                                        
       printf("msgsnd() write msg failed,errno=%d[%s]
",errno,(char *)strerror(errno));  
       exit(-1);                                                                  
    }                                                                             
  }                                                                               
  msgctl(msqid,IPC_RMID,0); //删除消息队列                                        
}                                                                                 

消息接收端 receive.c

/*receive.c */  
#include <stdio.h>   
#include <sys/types.h>   
#include <sys/ipc.h>   
#include <sys/msg.h>   
#include <errno.h>   
  
#define MSGKEY 1024   
  
struct msgstru  
{  
   long msgtype;  
   char msgtext[2048];  
};  
  
/*子进程，监听消息队列*/  
void childproc(int type){  
  struct msgstru msgs;  
  int msgid,ret_value;  
  char str[512];  
    
  while(1){  
     msgid = msgget(MSGKEY,IPC_EXCL );/*检查消息队列是否存在 */  
     if(msgid < 0){  
        printf(".
");//msq not existed! errno=%d [%s]
",errno,(char *)strerror(errno));  
        sleep(2);  
        continue;  
     }  
     /*接收消息队列*/  
     ret_value = msgrcv(msgid,&msgs,sizeof(struct msgstru),type,0);  
     printf("text=[%s] pid=[%d]
",msgs.msgtext,getpid());  
  }  
  return;  
}  
  
void main()  
{  
  int i,cpid;  
  
  /* create 2 child process */  
  for (i=1;i<=2;i++)
    {  
     cpid = fork();  
     if (cpid < 0)  
        printf("fork failed
");  
     else if (cpid ==0) /*child process*/  
         {
                 printf("pid=%d,type=%d",getpid(),i);
        childproc(i);  
         }
  }  
}  

运行如下：

jiang@jiang-GA-A75M-D2H:~/share/ss$ gcc -o receive receive.c
jiang@jiang-GA-A75M-D2H:~/share/ss$ gcc -o send send.c
jiang@jiang-GA-A75M-D2H:~/share/ss$ ./receive &  //接收进程后台运行
pid=18498,type=1.　　　　　　//进程[18498] 接收消息类型为“1”

pid=18499,type=2.　　　　　　//进程[18499] 接收消息类型为“2”

jiang@jiang-GA-A75M-D2H:~/share/ss$ ./send
input message type(end:0):1
input message to be sent:msg

text=[msg] pid=[18498]

input message type(end:0):1

input message to be sent:hello

text=[hello] pid=[18498]1

input message type(end:0):2
input message to be sent:meet

text=[meet] pid=[18499]

input message type(end:0):2

input message to be sent:meet2

text=[meet2] pid=[18499]

4、消息队列与命名管道的比较

 

　　消息队列跟命名管道有不少的相同之处，通过与命名管道一样，消息队列进行通信的进程可以是不相关的进程，同时它们都是通过发送和接收的方式来传递数据的。在命名管道中，发送数据用write，接收数据用read，则在消息队列中，发送数据用msgsnd，接收数据用msgrcv。而且它们对每个数据都有一个最大长度的限制。

 

与命名管道相比，消息队列的优势在于，1、消息队列也可以独立于发送和接收进程而存在，从而消除了在同步命名管道的打开和关闭时可能产生的困难。2、同时通过发送消息还可以避免命名管道的同步和阻塞问题，不需要由进程自己来提供同步方法。3、接收程序可以通过消息类型有选择地接收数据，而不是像命名管道中那样，只能默认地接收。