C语言进程间通信（三）

消息队列是最具有数据操作性的数据传输方式，在消息队列中可随意根据特定的数据类型检索消息，随内核持续的

消息队列是一个消息的链表，每个消息队列都有个队列头，用结构struct msg_queue描述，队列头包含队列的大量消息，包括消息队列键值，用户ID，组ID，消息数目等。

C代码  

1. struct msg_queue  
2. {  
3.     struct ipc_perm q_perm;  
4.     time_t q_stime; //最后一次msgsnd时间  
5.     time_t q_rtime; //最后一次msgrcv时间  
6.     time_t q_ctime; //最后一次变更时间  
7.     unsigned long q_cbytes; //当前消息队列中字节数目  
8.     unsigned long q_qnum;   //队列中消息个数  
9.     unsigned long q_qbytes; //队列中最大字节数目  
10.     pid_t q_lspid;  //最后msgsnd的进程ID  
11.     pid_t q_lrpid;  //最后receive进程ID  
12.     struct list_head q_messages;  
13.     struct list_head q_receivers;  
14.     struct list_head q_senders;  
15. }  

结构msqid_ds用来设置或返回消息队列的信息

C代码  

1. struct msqid_ds  
2. {  
3.     struct ipc_perm q_perm;  
4.     struct msg *msg_first;  //第一个消息  
5.     struct msg *msg_last;   //最后一个消息  
6.     time_t msg_stime;   //最后一次msgsnd时间  
7.     time_t msg_rtime;   //最后一次msgrcv时间  
8.     time_t msg_ctime;   //最后一次变更时间  
9.     pid_t msg_lspid;    //最后msgsnd的进程ID  
10.     pid_t msg_lrpid;    //最后receive进程ID  
11.     //...  
12. }  

消息队列读端

C代码  

1. //read_queue.c  
2. #include<sys/types.h>  
3. #include<sys/ipc.h>  
4. #include<sys/msg.h>  
5. #include<stdio.h>  
6. #include<sys/stat.h>  
7. #include<unistd.h>  
8. #include <errno.h>  
9.   
10. #define LEN 10  
11.   
12. typedef struct {  
13.         long int my_msg_type;  
14.         char msg[LEN+1];  
15. }msg_buf;  
16.   
17. int main()  
18. {  
19.         int ret;  
20.         int msg_id;  
21.   
22.         msg_id = msgget((key_t)1000,0666|IPC_CREAT);  
23.         if(msg_id == -1){  
24.                 printf("msgget failed\n");  
25.                 return -1;  
26.         }  
27.         printf("msg_id:%d\n",msg_id);  
28.         msg_buf mb;  
29.   
30.         ret = msgrcv(msg_id,(void *)&mb,sizeof(msg_buf),3,IPC_NOWAIT);  
31.         if(ret == -1){  
32.                 printf("msgrcv failed:%d\n",errno);  
33.                 return -1;  
34.         }  
35.         printf("recv %s\n",mb.msg);  
36.         return 0;  
37. }  

消息队列写端

C代码  

1. //create_queue.c  
2. #include<sys/types.h>  
3. #include<sys/ipc.h>  
4. #include<sys/msg.h>  
5. #include<stdio.h>  
6. #include<string.h>  
7. #include<sys/stat.h>  
8. #include<unistd.h>  
9. #include<errno.h>  
10.   
11. #define LEN 10  
12. typedef struct {  
13.         long int my_msg_type; //64位机器必须设置为long  
14.         char msg[LEN+1];  
15. }msg_buf;  
16.   
17. int main()  
18. {  
19.         int i;  
20.         int ret;  
21.         int msg_id;  
22.   
23.         msg_id = msgget((key_t)1000,0666|IPC_CREAT);  
24.         if(msg_id == -1){  
25.                 printf("msgget failed\n");  
26.                 return -1;  
27.         }  
28.         printf("msg_id=%d\n",msg_id);  
29.   
30.         msg_buf mb;  
31.         mb.my_msg_type = 3;  
32.         strncpy(mb.msg,"msg1",LEN);  
33.   
34.         ret = msgsnd(msg_id,(void *)&mb,sizeof(msg_buf),0);  
35.         if(ret == -1){  
36.                 printf("msgsnd failed\n");  
37.                 return -1;  
38.         }  
39.         printf("message sent:%d\n",ret);  
40.   
41.         return 0;  
42. }  

注意针对64位机器，必须设置type为long类型，不然消息不会被接收端收到

编译运行结果如下

Txt代码  

1. root:~/ciaos # ./write  
2. msg_id=327689  
3. message sent:0  
4. root:~/ciaos # ipcs -q  
5.   
6. ------ Message Queues --------  
7. key        msqid      owner      perms      used-bytes   messages  
8. 0x000003e8 327689     root       666        24           1  
9.   
10. root:~/ciaos # ./read  
11. msg_id:327689  
12. recv msg1  
13. root:~/ciaos # ipcs -q  
14.   
15. ------ Message Queues --------  
16. key        msqid      owner      perms      used-bytes   messages  
17. 0x000003e8 327689     root       666        0            0