您的位置: 首页  >  文章  >  Linux系统下-进程间通信（消息队列-详解）【转】

Linux系统下-进程间通信（消息队列-详解）【转】

分类: 文章 • 2023-03-19 16:20:25

参考书：《UNIX网络编程　卷２：进程间通信》  第5章 Posix消息队列  第6章 System V消息队列

原文地址：点击打开链接


Linux下进程间通信方式：

# 管道( pipe )：管道是一种半双工的通信方式，数据只能单向流动，而且只能在具有亲缘关系的进程间使用。进程的亲缘关系通常是指父子进程关系。

# 有名管道 (named pipe) ： 有名管道也是半双工的通信方式，但是它允许无亲缘关系进程间的通信。

# 信号量( semophore ) ： 信号量是一个计数器，可以用来控制多个进程对共享资源的访问。它常作为一种锁机制，防止某进程正在访问共享资源时，其他进程也访问该资源。因此，主要作为进程间以及同一进程内不同线程之间的同步手段。

# 消息队列( message queue ) ： 消息队列是由消息的链表，存放在内核中并由消息队列标识符标识。消息队列克服了信号传递信息少、管道只能承载无格式字节流以及缓冲区大小受限等缺点。

# 信号 ( sinal ) ： 信号是一种比较复杂的通信方式，用于通知接收进程某个事件已经发生。

# 共享内存( shared memory ) ：共享内存就是映射一段能被其他进程所访问的内存，这段共享内存由一个进程创建，但多个进程都可以访问。共享内存是最快的 IPC 方式，它是针对其他进程间通信方式运行效率低而专门设计的。它往往与其他通信机制，如信号两，配合使用，来实现进程间的同步和通信。

# 套接字( socket ) ： 套解口也是一种进程间通信机制，与其他通信机制不同的是，它可用于不同及其间的进程通信。

System V 与 POSIX的区别：
System V IPC存在时间比较老，许多系统都支持，但是接口复杂，并且可能各平台上实现略有区别（如ftok的实现及限制）。

POSIX是新标准，现在多数UNIX也已实现，我觉得如果只是开发的话，那么还是POSIX好，因为语法简单，并且各平台上实现都一样。

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

Linux用宏MSGMAX和MSGMNB来限制一条消息的最大长度和一个队列的最大长度。

1、每种进程通信方式实现方式和功能不一样，带来适用的场景也有所不同：
消息队列是链表队列，它通过内核提供一个struct msqid_ds *msgque[MSGMNI]向量维护内核的一个消息队列列表，因此linux系统支持的最大消息队列数由msgque数组大小来决定，每一个msqid_ds表示一个消息队列，并通过msqid_ds.msg_first、msg_last维护一个先进先出的msg链表队列，当发送一个消息到该消息队列时，把发送的消息构造成一个msg结构对象，并添加到msqid_ds.msg_first、msg_last维护的链表队列，同样，接收消息的时候也是从msg链表队列尾部查找到一个msg_type匹配的msg节点，从链表队列中删除该msg节点，并修改msqid_ds结构对象的数据。

2、消息队列的数据结构

struct msqid_ds *msgque[MSGMNI]向量：

       msgque[MSGMNI]是一个msqid_ds结构的指针数组，每个msqid_ds结构指针代表一个系统消息队列，msgque[MSGMNI]的大小为MSGMNI=128，也就是说系统最多有MSGMNI=128个消息队列。


3、消息队列Key的获取：

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

http://blog.csdn.net/stonecao/article/details/10364287
Linux系统下-进程间通信（消息队列-详解）【转】

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

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

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

1、创建或者使用消息队列：msgget函数
该函数用来创建和访问一个消息队列。它的原型为：
[cpp] view plain copy
  1. int msgget(key_t, key, int msgflg);  

与其他的IPC机制一样，程序必须提供一个键来命名某个特定的消息队列。msgflg是一个权限标志，表示消息队列的访问权限，它与文件的访问权限一样。msgflg可以与IPC_CREAT做或操作，表示当key所命名的消息队列不存在时创建一个消息队列，如果key所命名的消息队列存在时，IPC_CREAT标志会被忽略，而只返回一个标识符。

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

申请一块内存，创建一个新的消息队列（数据结构msqid_ds)，将其初始化后加入到msgque向量表中的某个空位置处，返回标示符。或者在msgque向量表中找键值为key的消息队列。


2、将消息添加到消息队列中：

[cpp] view plain copy
  1. int msgsend(int msgid, const void *msg_ptr, size_t msg_sz, int msgflg);  

msgid是由msgget函数返回的消息队列标识符。

msg_ptr是一个指向准备发送消息的指针，但是消息的数据结构却有一定的要求，指针msg_ptr所指向的消息结构一定要是以一个长整型成员变量开始的结构体，接收函数将用这个成员来确定消息的类型。所以消息结构要定义成这样：
[cpp] view plain copy
  1. struct my_message{    
  2.     long int message_type;    
  3.     /* The data you wish to transfer*/    
  4. };  
msg_sz是msg_ptr指向的消息的长度，注意是消息的长度，而不是整个结构体的长度，也就是说msg_sz是不包括长整型消息类型成员变量的长度。
msgflg用于控制当前消息队列满或队列消息到达系统范围的限制时将要发生的事情。
如果调用成功，消息数据的一分副本将被放到消息队列中，并返回0，失败时返回-1.

3、从一个消息队列中获取消息：
[cpp] view plain copy
  1. int msgrcv(int msgid, void *msg_ptr, size_t msg_st, long int msgtype, int msgflg);  
msgid, msg_ptr, msg_st的作用也函数msgsnd函数的一样。
msgtype可以实现一种简单的接收优先级。如果msgtype为0，就获取队列中的第一个消息。如果它的值大于零，将获取具有相同消息类型的第一个信息。如果它小于零，就获取类型等于或小于msgtype的绝对值的第一个消息。
msgflg用于控制当队列中没有相应类型的消息可以接收时将发生的事情。
调用成功时，该函数返回放到接收缓存区中的字节数，消息被复制到由msg_ptr指向的用户分配的缓存区中，然后删除消息队列中的对应消息。失败时返回-1.

4、消息队列控制函数：
[cpp] view plain copy
  1. int msgctl(int msgid, int command, struct msgid_ds *buf);  
command是将要采取的动作，它可以取3个值，
    IPC_STAT：把msgid_ds结构中的数据设置为消息队列的当前关联值，即用消息队列的当前关联值覆盖msgid_ds的值。
    IPC_SET：如果进程有足够的权限，就把消息列队的当前关联值设置为msgid_ds结构中给出的值
    IPC_RMID：删除消息队列
buf是指向msgid_ds结构的指针，它指向消息队列模式和访问权限的结构。msgid_ds结构至少包括以下成员：
[cpp] view plain copy
  1. struct msgid_ds    
  2. {    
  3.     uid_t shm_perm.uid;    
  4.     uid_t shm_perm.gid;    
  5.     mode_t shm_perm.mode;    
  6. };  
成功时返回0，失败时返回-1.

消息发送端：send.c

[cpp] view plain copy
  1. /*send.c*/    
  2. #include <stdio.h>     
  3. #include <sys/types.h>     
  4. #include <sys/ipc.h>     
  5. #include <sys/msg.h>     
  6. #include <errno.h>     
  7.   
  8. #define MSGKEY 1024     
  9.     
  10. struct msgstru    
  11. {    
  12.    long msgtype;    
  13.    char msgtext[2048];     
  14. };    
  15.     
  16. main()    
  17. {    
  18.   struct msgstru msgs;    
  19.   int msg_type;    
  20.   char str[256];    
  21.   int ret_value;    
  22.   int msqid;    
  23.     
  24.   msqid=msgget(MSGKEY,IPC_EXCL);  /*检查消息队列是否存在*/    
  25.   if(msqid < 0){    
  26.     msqid = msgget(MSGKEY,IPC_CREAT|0666);/*创建消息队列*/    
  27.     if(msqid <0){    
  28.     printf("failed to create msq | errno=%d [%s]\n",errno,strerror(errno));    
  29.     exit(-1);    
  30.     }    
  31.   }     
  32.      
  33.   while (1){    
  34.     printf("input message type(end:0):");    
  35.     scanf("%d",&msg_type);    
  36.     if (msg_type == 0)    
  37.        break;    
  38.     printf("input message to be sent:");    
  39.     scanf ("%s",str);    
  40.     msgs.msgtype = msg_type;    
  41.     strcpy(msgs.msgtext, str);    
  42.     /* 发送消息队列 */    
  43.     ret_value = msgsnd(msqid,&msgs,sizeof(struct msgstru),IPC_NOWAIT);    
  44.     if ( ret_value < 0 ) {    
  45.        printf("msgsnd() write msg failed,errno=%d[%s]\n",errno,strerror(errno));    
  46.        exit(-1);    
  47.     }    
  48.   }    
  49.   msgctl(msqid,IPC_RMID,0); //删除消息队列     
  50. }  

消息接收端 receive.c

[cpp] view plain copy
  1. /*receive.c */    
  2. #include <stdio.h>     
  3. #include <sys/types.h>     
  4. #include <sys/ipc.h>     
  5. #include <sys/msg.h>     
  6. #include <errno.h>     
  7.     
  8. #define MSGKEY 1024     
  9.     
  10. struct msgstru    
  11. {    
  12.    long msgtype;    
  13.    char msgtext[2048];    
  14. };    
  15.     
  16. /*子进程，监听消息队列*/    
  17. void childproc(){    
  18.   struct msgstru msgs;    
  19.   int msgid,ret_value;    
  20.   char str[512];    
  21.       
  22.   while(1){    
  23.      msgid = msgget(MSGKEY,IPC_EXCL );/*检查消息队列是否存在 */    
  24.      if(msgid < 0){    
  25.         printf("msq not existed! errno=%d [%s]\n",errno,strerror(errno));    
  26.         sleep(2);    
  27.         continue;    
  28.      }    
  29.      /*接收消息队列*/    
  30.      ret_value = msgrcv(msgid,&msgs,sizeof(struct msgstru),0,0);    
  31.      printf("text=[%s] pid=[%d]\n",msgs.msgtext,getpid());    
  32.   }    
  33.   return;    
  34. }    
  35.     
  36. void main()    
  37. {    
  38.   int i,cpid;    
  39.     
  40.   /* create 5 child process */    
  41.   for (i=0;i<5;i++){    
  42.      cpid = fork();    
  43.      if (cpid < 0)    
  44.         printf("fork failed\n");    
  45.      else if (cpid ==0) /*child process*/    
  46.         childproc();    
  47.   }    
  48. }  


若父进程退出，子进程尚未结束，则子进程会被init进程领养，也就是说init进程将成为该子进程的父进程。

若希望父进程退出，子进程也退出的话，可以使用线程，因为若进程结束，则还没结束的线程一定会立刻结束。


另外：以上是system v标准下的消息队列接口，如果要使用POSIX标准来创建消息队列，1、mq_open来创建非默认个数大小消息队列：

函数原型

mqd_t mq_open(const char *name, int oflag, mode_t mode, struct mq_attr *attr);
 第4个参数为 mq_attr 指针
 struct mq_attr{ 
   long mq_flags;    
   long mq_maxmsg;    
   long mq_msgsize;    
   long mq_curmsgs; };
 当第四个参数为空指针时，就使用默认属性。  
当指向mq_attr结构的指针作为参数时，允许我们在该函数的实际操作时创建一个新队列时，给它指定mq_maxmsg和mq_msgsize属性.mq_open忽略该结构的另外两个成员.

（1）attr.mq_maxmsg 不能超过文件 /proc/sys/fs/mqueue/msg_max 中的数值；

（2）attr.mq_msgsize不能超过 /proc/sys/fs/mqueue/msgsize_max 的数值；

（3）消息队列名称前面必须加上斜杆。

在POSIX消息队列中 msg_max 默认为 10 ，msgsize_max 默认为8192 ，否则会报错！！！
可以在 /proc/sys/fs/mqueue# cat msg_max        /proc/sys/fs/mqueue# cat msgsize_max 查看
修改的话，要使用：echo 1000 > /proc/sys/fs/mqueue/msg_max往里面写。


2、获取消息队列的属性 
一个进程在发送和接收消息之前，需要了解消息对象的属性，如消息的最大长度。以便
设定接收和发送的buffer大小。 mqd_t mq_getattr(mqd_t mqdes, struct mq_attr *attr);参数： 
Mqdes：打开消息队列时获取的描述符。 
Attr：指向结构struct mq_attr的指针，用来获取消息队列的四个属性 
struct mq_attr { 
    long mq_flags;    // 0或者O_NONBLOCK 
    long mq_maxmsg; //队列中包含的消息数的最大限制数  

    long mq_msgsize; //每个消息大小的最大限制数

    long mq_curmsgs;  //当前队列中的消息数 

} 
  
3、设置消息队列属性 
我们可以设置消息队列的属性，实际只能设置flag标志，说明队列中没有消息时，接收消息的进程是否在队列上继续等待。 
mqd_t mq_setattr(mqd_t mqdes, struct mq_attr *newattr, struct mq_attr *oldattr); 
参数： 
Mqdes：打开消息队列时获取的描述符。 
Attr：指向结构struct mq_attr的指针，用来获取消息队列的最大消息个数和最大消息长
度。放到数据结构的mq_maxmsg和mq_msgsize中。

 struct mq_attr { 
    long mq_flags;    // 0或者O_NONBLOCK，只能设置这个

    long mq_maxmsg; //队列中包含的消息数的最大限制数 

    long mq_msgsize; //每个消息大小的最大限制数   

    long mq_curmsgs;  //当前队列中的消息数

 } 
oldattr：用来保存设置之前的attr值，可以为NULL. 


4、发送消息 
进程在打开消息队列后，可以使用下面的函数发送消息 
int mq_send(mqd_t mqdes, const char *ptr, size_t len, unsigned int prio); 
参数： 
mqdes: 打开消息队列时获得的描述符。 
ptr: 指向发送缓冲区的指针，发送缓冲区存放了要发送的数据。 
Len: 要发送的数据的长度。 prio ：消息的优先级；它是一个小于 MQ_PRIO_MAX 的数，数值越大，优先级越高。 
POSIX 消息队列在调用 mq_receive 时总是返回队列中 最高优先级的最早消息 。如果消息不需要设定优先级，那么可以在 mq_send 是置 prio 为 0 ， mq_receive 的 prio 置为 NULL 。  返回值：发送成功，返回0，失败，返回-1.    


5、接收消息 
进程在打开消息队列后，可以使用下面的函数接收消息。 
ssize_t mq_receive(mqd_t mqdes, char *ptr, size_t len, unsigned int *prio); 
参数： 
mqdes: 打开消息队列时获得的描述符。 
ptr: 指向接收缓冲区的指针。接收缓冲区用来存放收到的消息。 
Len: 接收缓冲区的长度。 len不能小于mq_msgsize，否则会返回EMSGSIZE prio ：消息的优先级；它是一个小于 MQ_PRIO_MAX 的数，数值越大，优先级越高。 POSIX 消息队列在调用 mq_receive 时总是返回队列中 最高优先级的最早消息 。如果消息不需要设定优先级，那么可以在 mq_send 是置 prio 为 0 ， mq_receive 的 prio 置为 NULL 。 返回值：  接收成功，返回0，失败，返回-1.


6、消息队列的关闭 
mqd_t mq_close(mqd_t mqdes); 关闭消息队列，但不能删除它 成功返回0，失败返回-1   


7、删除消息队列 
 mqd_t mq_unlink(const char *name); 成功返回0，失败返回-1 
当某个进程还没有关闭此消息队列时，调用mq_unlink时，不会马上删除队列，当最后一个进程关闭队列时，该队列被删除


[cpp] view plain copy
  1. 编译：  
  2.   
  3. gcc -o consumer consumer.c -lrt  
  4.   
  5. gcc -o producer producer.c -lrt  
  6.   
  7. /* 
  8.  
  9.  * 
  10.  *       Filename:  producer.c 
  11.  * 
  12.  *    Description:  生产者进程 
  13.  * 
  14.  *        Version:  1.0 
  15.  *        Created:  09/30/2011 04:52:23 PM 
  16.  *       Revision:  none 
  17.  *       Compiler:  gcc(g++) 
  18.  * 
  19.  *         Author:  |Zhenghe Zhang|, |[email protected]| 
  20.  *        Company:  |Shenzhen XXX Technology Co., Ltd.| 
  21.  * 
  22.  */  
  23.   
  24. #include <stdio.h>  
  25. #include <mqueue.h>  
  26. #include <sys/stat.h>  
  27. #include <stdlib.h>  
  28. #include <unistd.h>  
  29. #include <time.h>  
  30. #include <string.h>  
  31.   
  32. #define MAXSIZE     10   //定义buf大小  
  33. #define BUFFER      8192 //定义Msg大小  
  34.   
  35. struct MsgType{  
  36.     int len;  
  37.     char buf[MAXSIZE];  
  38.     char x;  
  39.     short y;  
  40. };  
  41.   
  42. int main()   
  43. {   
  44.     /*消息队列*/  
  45.     mqd_t msgq_id;  
  46.     struct MsgType msg;  
  47.   
  48.     unsigned int prio = 1;  
  49.     unsigned int send_size = BUFFER;  
  50.   
  51.     struct mq_attr msgq_attr;  
  52.     const char *file = "/posix";  
  53.   
  54.     /*mq_open() for creating a new queue (using default attributes) */  
  55.     /*mq_open() 创建一个新的 POSIX 消息队列或打开一个存在的队列*/  
  56.     msgq_id = mq_open(file, O_RDWR | O_CREAT, S_IRWXU | S_IRWXG, NULL);  
  57.     if(msgq_id == (mqd_t)-1)  
  58.     {  
  59.         perror("mq_open");  
  60.         exit(1);  
  61.     }  
  62.   
  63.     /* getting the attributes from the queue        --  mq_getattr() */  
  64.     if(mq_getattr(msgq_id, &msgq_attr) == -1)  
  65.     {  
  66.         perror("mq_getattr");  
  67.         exit(1);  
  68.     }  
  69.   
  70.     printf("Queue \"%s\":\n\t- stores at most %ld messages\n\t- \  
  71.         large at most %ld bytes each\n\t- currently holds %ld messages\n",   
  72.         file, msgq_attr.mq_maxmsg, msgq_attr.mq_msgsize, msgq_attr.mq_curmsgs);  
  73.      
  74.     /*setting the attributes of the queue        --  mq_setattr() */  
  75.     /*mq_setattr() 设置消息队列的属性，设置时使用由 newattr 指针指向的 mq_attr 结构的信息。*/  
  76.     /*属性中只有标志 mq_flasgs 里的 O_NONBLOCK 标志可以更改，其它在 newattr 内的域都被忽略 */  
  77.     if(mq_setattr(msgq_id, &msgq_attr, NULL) == -1)  
  78.     {  
  79.         perror("mq_setattr");  
  80.         exit(1);  
  81.     }     
  82.   
  83.     int i = 0;   
  84.     while(i < 10)   
  85.     {  
  86.         msg.len = i;  
  87.         memset(msg.buf, 0, MAXSIZE);  
  88.         sprintf(msg.buf, "0x%x", i);  
  89.         msg.x = (char)(i + 'a');  
  90.         msg.y = (short)(i + 100);  
  91.   
  92.         printf("msg.len = %d, msg.buf = %s, msg.x = %c, msg.y = %d\n", msg.len, msg.buf, msg.x, msg.y);  
  93.   
  94.         /*sending the message      --  mq_send() */  
  95.         /*mq_send() 把 msg_ptr 指向的消息加入由 mqdes 引用的消息队列里。*/  
  96.         /*参数 msg_len 指定消息 msg_ptr 的长度：这个长度必须小于或等于队列 mq_msgsize 属性的值。零长度的消息是允许。*/  
  97.         if(mq_send(msgq_id, (char*)&msg, sizeof(struct MsgType), prio) == -1)  
  98.         {  
  99.             perror("mq_send");  
  100.             exit(1);  
  101.         }  
  102.   
  103.         i++;  
  104.         sleep(1);     
  105.     }  
  106.   
  107.     sleep(30); //等待消费者进程退出  
  108.   
  109.     /*closing the queue        -- mq_close() */  
  110.     /*mq_close() 关闭消息队列描述符 mqdes。如果调用进程在消息队列 mqdes 绑定了通知请求，*/  
  111.     /*那么这个请求被删除，此后其它进程就可以绑定通知请求到此消息队列。*/  
  112.     if(mq_close(msgq_id) == -1)  
  113.     {  
  114.         perror("mq_close");  
  115.         exit(1);  
  116.     }  
  117.   
  118.     /*mq_unlink() 删除名为 name 的消息队列。消息队列名将被直接删除。*/  
  119.     /*消息队列本身在所有引用这个队列的描述符被关闭时销毁。*/  
  120.     if(mq_unlink(file) == -1)  
  121.     {  
  122.         perror("mq_unlink");  
  123.         exit(1);  
  124.     }  
  125.   
  126.     return 0;   
  127. }  
  128.   
  129.    


[cpp] view plain copy
  1. /* 
  2.  * 
  3.  *       Filename:  consumer.c 
  4.  * 
  5.  *    Description:  消费者进程 
  6.  * 
  7.  *        Version:  1.0 
  8.  *        Created:  09/30/2011 04:52:23 PM 
  9.  *       Revision:  none 
  10.  *       Compiler:  gcc(g++) 
  11.  * 
  12.  *         Author:  |Zhenghe Zhang|, |[email protected]| 
  13.  *        Company:  |Shenzhen XXX Technology Co., Ltd.| 
  14.  * 
  15.  */  
  16.   
  17. #include <stdio.h>  
  18. #include <mqueue.h>  
  19. #include <sys/stat.h>  
  20. #include <stdlib.h>  
  21. #include <unistd.h>  
  22. #include <time.h>  
  23. #include <string.h>  
  24.   
  25. #define MAXSIZE     10   //定义buf大小  
  26. #define BUFFER      8192 //定义Msg大小  
  27.   
  28. struct MsgType{  
  29.     int len;  
  30.     char buf[MAXSIZE];  
  31.     char x;  
  32.     short y;  
  33. };  
  34.   
  35. int main()   
  36. {   
  37.     /*消息队列*/  
  38.     mqd_t msgq_id;  
  39.     struct MsgType msg;  
  40.   
  41.     unsigned int sender;  
  42.     struct mq_attr msgq_attr;  
  43.   
  44.     unsigned int recv_size = BUFFER;  
  45.     const char *file = "/posix";  
  46.   
  47.     /* mq_open() for opening an existing queue */  
  48.     msgq_id = mq_open(file, O_RDWR);  
  49.     if(msgq_id == (mqd_t)-1)  
  50.     {  
  51.         perror("mq_open");  
  52.         exit(1);  
  53.     }  
  54.   
  55.     /* getting the attributes from the queue        --  mq_getattr() */  
  56.     if(mq_getattr(msgq_id, &msgq_attr) == -1)  
  57.     {  
  58.         perror("mq_getattr");  
  59.         exit(1);  
  60.     }  
  61.   
  62.     printf("Queue \"%s\":\n\t- stores at most %ld messages\n\t- \  
  63.         large at most %ld bytes each\n\t- currently holds %ld messages\n",   
  64.         file, msgq_attr.mq_maxmsg, msgq_attr.mq_msgsize, msgq_attr.mq_curmsgs);  
  65.   
  66.     if(recv_size < msgq_attr.mq_msgsize)  
  67.         recv_size = msgq_attr.mq_msgsize;  
  68.   
  69.     int i = 0;  
  70.     while(i < 10) //运行一个consumenr，为 10 ，同时运行两个consumer进程，为 5    
  71.     {  
  72.         msg.len = -1;  
  73.         memset(msg.buf, 0, MAXSIZE);  
  74.         msg.x = ' ';  
  75.         msg.y = -1;  
  76.    
  77.         /* getting a message */  
  78.   
  79.         /*mq_receive() 从由描述符 mqdes 引用的队列时删除优先级最高的最老的消息，并把放置到 msg_ptr 的缓存区内。*/  
  80.         /*参数 msg_len 指定缓冲区 msg_ptr 的大小：它必须大于队列的 mq_msgsize 属性(参数 mq_getattr)。*/   
  81.         /*如果 prio 不是 NULL，那么它指向的内存用于返回收到消息相关的优先级。*/  
  82.         if (mq_receive(msgq_id, (char*)&msg, recv_size, &sender) == -1)   
  83.         {  
  84.             perror("mq_receive");  
  85.             exit(1);  
  86.         }  
  87.   
  88.         printf("msg.len = %d, msg.buf = %s, msg.x = %c, msg.y = %d\n", msg.len, msg.buf, msg.x, msg.y);  
  89.   
  90.         i++;  
  91.         sleep(2);   
  92.     }  
  93.   
  94.     if(mq_close(msgq_id) == -1)  
  95.     {  
  96.         perror("mq_close");  
  97.         exit(1);  
  98.     }  
  99.   
  100.     return 0;   
  101. }  


1、僵尸进程；2、共享内存；3、延时函数；4、kill信号；5、fork子进程；6信号量；

相关推荐