Linux进程间通信（消息队列）

消息可以理解为写信给某个人，这里在应用中是告诉系统写信人和写信的内容就可以了，

别人会来看发信人是谁，如果不是自己想要的就放弃读信或者只要有消息自己就读取消息

消息队列就是按队列的方式处理很多消息，先发的最先被读

消息队列：

http://www.2cto.com/os/201205/129794.html

http://home.lupaworld.com/home-space-uid-56821-do-blog-id-231645.html

1)消息队列是一种以链表式结构组织的一组数据,存放在内核中,是由各进程通过消息队列标识符来引用的一种数据传送方式.
2)有两种可以创建消息队列的API函数:system V和POSIX,两者稍有不同,但原理一样.
3)这两类消息队列都采用固定大小,而且要确保所有进程遵循相同的消息结构,接受者必须确定消息的大小,并一次对信息进行读取,否则读取失败.
4)msgget返回的消息队列ID在进程间是有效的,即父子进程或者并行进程都可以用消息队列的方式进行通信.
5)两种API函数的侧重点都略有不同,System V中消息的优先级有一定的弹性,但是POSIX却严格地遵循优先级的顺序.

消息队列函数

-----------------------------------------------------

linux消息队列函数

--------------------------------

头文件：

#include <sys/types.h>

#include <sys/ipc.h>

#include <sys/msg.h>

  www.2cto.com  

------------------------------------------

1、系统建立IPC通讯（如消息队列、共享内存时）必须指定一个ID值。通常情况下，该id值通过ftok函数得到。

ftok原型如下：

key_t ftok( char * fname, int id )

fname就时你指定的文件名，id是子序号。

在一般的UNIX实现中，是将文件的索引节点号取出，前面加上子序号得到key_t的返回值。

如指定文件的索引节点号为65538，换算成16进制为0x010002，而你指定的ID值为38，换算成16 进制为0x26，则最后的key_t返回值为0x26010002。

查询文件索引节点号的方法是： ls -i

当删除重建文件后，索引节点号由操作系统根据当时文件系统的使用情况分配，因此与原来不同，所以得到的索引节点号也不同。

如果要确保key_t值不变，要目确保ftok的文件不被删除，要么不用ftok，指定一个固定的key_t 值，比如:

#define IPCKEY 0x111

char path[256];

    sprintf( path, "%s/etc/config.ini", (char*)getenv("HOME") );

    msgid=ftok( path, IPCKEY );[/code]

同一段程序，用于保证两个不同用户下的两组相同程序获得互不干扰的IPC键值。

由于 etc/config.ini（假定）为应用系统的关键配置文件，因此不存在被轻易删除的问题——即使被删，也会很快被发现并重建（此时应用系统也将被重起）。

ftok()的设计目的也在于此。

 

----------------------------------------------------

2、int msgget(key_t key, int msgflg); //创建消息队列

参数：

    key：消息队列关联的键。为IPC_PRIVATE时表示创建自己的消息队列

    msgflg：消息队列的建立标志和访问权限。msgflg 的低位用来确定消息队列的访问权限。

        IPC_CREAT：如果 key不存在，创建

        IPC_EXCL：如果 key 存在，返回失败

        IPC_NOWAIT：如果需要等待，直接返回错误

        如果单独使用IPC_CREAT，则msgget()要么返回一个新创建的消息队列的标识符，要么返回具有相同关键字值的队列的标识符。如果 IPC_EXCL和IPC_CREAT一起使用，则msgget()要么创建一个新的消息队列，要么如果队列已经存在则返回一个失败值-1。

    

返回说明：

如果成功，返回消息队列标识符

如果失败，则返回-1：errno=EACCESS(权限不允许)

EEXIST(队列已经存在，无法创建)

EIDRM(队列标志为删除)

ENOENT(队列不存在)

ENOMEM(创建队列时内存不够)

ENOSPC(超出最大队列限制) 

  www.2cto.com  

举例：

msgid=msgget(IPC_PRIVATE,IPC_CREAT|IPC_EXCL|00666); //创建消息队列

 

--------------------------------------------------

3、int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg); //将消息送入消息队列

参数：  

    msqid：消息队列的标识符。

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

 

struct msgbuf {

    long mtype;     /* 消息类型，必须 > 0 */

    char mtext[1];  /* 消息文本 */

};

    msgsz：消息的大小。

    msgflg：用来指明进程在队列数据满(msgsnd)或空(msgrcv)的情况下所应采取的行动。

        如果设置为 IPC_NOWAIT，则在消息队列已满时不发送消息并且调用进程立即返回错误信息EAGAIN。

        如果设置为 0，则调用进程阻塞直至消息队列不为满。

        

返回说明：  

成功执行时，msgsnd()返回0, 失败返回-1

 

举例：msgsnd(g_msg_id,&msg_snd,sizeof(msg_snd.msg_item),IPC_NOWAIT); //非阻塞发送消息    

 

----------------------------------------------------------

4、ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp, int msgflg); //从消息队列读取信息

参数：

    msgtyp:

    msgtyp = 0：收取队列中的第一条消息，任意类型。

    msgtyp > 0：收取第一条 msgtyp 类型的消息。  这个能判断自己该不该收这个消息是不是想要的发信人发来的

    msgtyp < 0：收取第一条最低类型（小于或等于 msgtyp 的绝对值）的消息。 

    其他参数参考msgsnd函数。

    

返回说明：  

成功执行时，msgrcv()返回0, 失败返回-1

 

举例：msgrcv(msgid,&msg_rbuf,sizeof(msg_rbuf.msg_item),10,0); //阻塞接收

  www.2cto.com  

----------------------------------------------------------

5、int msgctl (int msqid, int cmd, struct msqid_ds *buf); //消息队列属性控制 

参数：

    msqid：消息队列的标识符。

    cmd：执行的控制命令，即要执行的操作。包括以下选项：

        IPC_STAT：读取消息队列属性。取得此队列的msqid_ds 结构，并将其存放在buf指向的结构中。 

        IPC_SET ：设置消息队列属性。

        IPC_RMID：删除消息队列。

        IPC_INFO：读取消息队列基本情况。此命令等同于 ipcs 命令。

        这 4 条命令（IPC_STAT、IPC_SET、IPC_INFO 和 IPC_RMID）也可用于信号量和共享存储。

    buf：临时的 msqid_ds 结构体类型的变量。用于存储读取的消息队列属性或需要修改的消息队列属性。

    

举例：msgctl(qid, IPC_RMID, NULL)  //删除消息队列

 

 

 

 

摘自 pj81102的专栏

实例1：一个程序，自己发消息，然后自己再从队列上读消息

[cpp]  view plain  copy

 print ?

1. /*msgque.c*/  
2. #include <sys/types.h>  
3. #include <sys/ipc.h>  
4. #include <sys/msg.h>  
5. #include <stdio.h>  
6. #include <stdlib.h>  
7. #include <unistd.h>  
8. #include <string.h>  
9. #define  BUFSZ      512  
10.   
11. struct message  
12. {  
13.     long msg_type;  
14.     char msg_text[BUFSZ];  
15. };  
16.   
17. int main()  
18. {  
19.     int qid;  
20.     key_t key;  
21.     int len;  
22.     struct message msg;  
23.       
24.     /*根据不同的路径和关键表示产生标准的key*/  
25.     if ((key = ftok(".", 'a')) == -1)  
26.     {  
27.         perror("ftok");  
28.         exit(1);  
29.     }  
30.       
31.     /*创建消息队列*/  
32.     if ((qid = msgget(key,IPC_CREAT|0666)) == -1)  
33.     {  
34.         perror("msgget");  
35.         exit(1);  
36.     }  
37.       
38.     printf("Opened queue %d\n",qid);  
39.     puts("Please enter the message to queue:");  
40.       
41.     if ((fgets((&msg)->msg_text, BUFSZ, stdin)) == NULL)   //消息内容  
42.     {  
43.         puts("no message");  
44.         exit(1);  
45.     }  
46.       
47.     msg.msg_type = getpid();                       //消息类型，可以理解为发信人名字  
48.     len = strlen(msg.msg_text);  
49.       
50.     /*添加消息到消息队列*/  
51.     if ((msgsnd(qid, &msg, len, 0)) < 0)           //把消息加到队列  
52.     {  
53.         perror("message posted");  
54.         exit(1);  
55.     }  
56.       
57.     /*读取消息队列*/  
58.     if (msgrcv(qid, &msg, BUFSZ, getpid(), 0) < 0)     //读发信人为getpid()的消息  
59.     {  
60.         perror("msgrcv");  
61.         exit(1);  
62.     }  
63.       
64.     printf("message is:%s\n",(&msg)->msg_text);  
65.       
66.     /*从系统内核中移走消息队列 */  
67.     if ((msgctl(qid, IPC_RMID, NULL)) < 0)  
68.     {  
69.         perror("msgctl");  
70.         exit(1);  
71.     }  
72.       
73.     exit(0);  
74. }  

实例2：一个程序发送消息   另一个接收消息，读的是第一条消息不判断是不是自己想要的消息

[cpp]  view plain  copy

 print ?

1. /* msgsnd.c */  
2.   
3.   
4. #include <sys/types.h>  
5. #include <sys/ipc.h>  
6. #include <sys/msg.h>  
7. #include <stdio.h>  
8. #include <stdlib.h>  
9. #include <unistd.h>  
10. #include <string.h>  
11. #define  BUFFER_SIZE 512  
12.   
13.   
14. struct message  
15. {  
16.     long msg_type;  
17.     char msg_text[BUFFER_SIZE];  
18. };  
19.   
20.   
21. int main()  
22. {  
23. int qid;  
24. key_t key;  
25. struct message msg;  
26.   
27. /*根据不同的路径和关键表示产生标准的key*/  
28. if ((key = ftok(".", 'a')) == -1)  
29. {  
30.     perror("ftok");  
31.     exit(1);  
32. }  
33.   
34. /*创建消息队列*/  
35. if ((qid = msgget(key, IPC_CREAT|0666)) == -1)  
36. {  
37.     perror("msgget");  
38.     exit(1);  
39. }  
40. printf("Open queue %d\n",qid);  
41.   
42. while(1)  
43. {  
44.    printf("Enter some message to the queue(enter 'quit' to exit):");  
45.     if ((fgets(msg.msg_text, BUFFER_SIZE, stdin)) == NULL)  
46.     {  
47.         puts("no message");  
48.         exit(1);  
49.     }  
50.   
51. msg.msg_type = getpid();  
52.   
53. /*添加消息到消息队列*/  
54. if ((msgsnd(qid, &msg, strlen(msg.msg_text), 0)) < 0)  
55. {  
56. perror("message posted");  
57. exit(1);  
58. }  
59.   
60. if (strncmp(msg.msg_text, "quit", 4) == 0)  
61. {  
62. break;  
63. }  
64. }  
65.   
66. exit(0);  
67. }  

[cpp]  view plain  copy

 print ?

1. /* msgrcv.c */  
2.   
3. #include <sys/types.h>  
4. #include <sys/ipc.h>  
5. #include <sys/msg.h>  
6. #include <stdio.h>  
7. #include <stdlib.h>  
8. #include <unistd.h>  
9. #include <string.h>  
10. #define  BUFFER_SIZE        512  
11.   
12. struct message  
13. {  
14.     long msg_type;  
15.     char msg_text[BUFFER_SIZE];  
16. };  
17.   
18. int main()  
19. {  
20.     int qid;  
21.     key_t key;  
22.     struct message msg;  
23.       
24.     /*根据不同的路径和关键表示产生标准的key*/  
25.     if ((key = ftok(".", 'a')) == -1)  
26.     {  
27.         perror("ftok");  
28.         exit(1);  
29.     }  
30.       
31.     /*创建消息队列*/  
32.     if ((qid = msgget(key, IPC_CREAT|0666)) == -1)  
33.     {  
34.         perror("msgget");  
35.         exit(1);  
36.     }  
37.     printf("Open queue %d\n", qid);  
38.       
39.     do  
40.     {  
41.         /*读取消息队列*/  
42.         memset(msg.msg_text, 0, BUFFER_SIZE);  
43.         if (msgrcv(qid, (void*)&msg, BUFFER_SIZE, 0, 0) < 0)   //读取消息不管是谁发的  
44.         {  
45.             perror("msgrcv");  
46.             exit(1);  
47.         }  
48.         printf("The message from process %d : %s", msg.msg_type, msg.msg_text);       
49.           
50.     } while(strncmp(msg.msg_text, "quit", 4));  
51.       
52.       
53.     /*从系统内核中移走消息队列 */  
54.     if ((msgctl(qid, IPC_RMID, NULL)) < 0)  
55.     {  
56.         perror("msgctl");  
57.         exit(1);  
58.     }  
59.       
60.     exit(0);  
61. }  

实例3

/*设计两个程序，要求用消息队列实现聊天程序，每次发言后自动在后面增加当前系统时间。增加结束字符，比如最后输入“88”后结束今年成*/

/*未实现自动添加当前系统时间和结束字符*/

/*第一个程序，先添加消息后读取消息*/
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <string.h>
#include <time.h>

struct msgmbuf    /*定义消息的结构体*/
{
    long msg_type;        /*消息类型*/
    int msg_date;           /*添加系统时间*/
    char msg_text[1024];      /*消息内容*/
};

int main()
{
    int ret;
    int qid;
    key_t key;
    struct msgmbuf msg;

    msg.msg_type=100;     /*定义写入消息类型为100*/

    key=ftok(".",'a');   /*产生标准key*/
    if(key==-1)
    {
        perror("产生标准key错误!\n");
        exit(1);
    }

    qid=msgget(key,IPC_CREAT|0666);      /*创建消息队列返回值为qid*/
    if(qid==-1)
    {
        perror("创建消息队列失败!");
        exit(1);
    }

    while(1)
    {
    /*从键盘获取发送内容，并利用msgsnd添加消息，ret判断添加消息是否成功*/
        printf("请输入发送内容:\n");
        scanf("%s",&msg.msg_text);
        msg.msg_date=system("date|cut -d' ' -f 5");              /*添加系统时间*/
        ret=msgsnd(qid,&msg,sizeof(msg.msg_text),msg.msg_type);
        if(ret<0)
        {
            perror("添加消息失败!");
            exit(1);
        }

    /*定义读取消息类型为200利用msgrcv读取消息，并添加到标准输出*/
        msg.msg_type=200;
        msgrcv(qid,&msg,sizeof(msg),msg.msg_type,0);    
        if(ret<0)
        {
            perror("读取消息失败!");
            exit(1);
        }
        printf("读取的内容为:\n%s\n",msg.msg_text);
    }

    msgctl(qid,IPC_RMID,NULL);     /*关闭消息队列*/
    return 0;
}


/*第二个程序，先读取消息后添加消息*/
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>

struct msgmbuf     /*定义消息结构体*/
{
    int msg_type;         /*消息类型*/
    int msg_date;         /*消息发送时间*/
    char msg_text[1024];      /*消息内容*/
};

int main()
{
    int ret;
    int qid;
    key_t key;
    struct msgmbuf msg;

    msg.msg_type=100;          /*读取消息类型为100*/

    key=ftok(".",'a');         /*产生标准key*/
    if(key==-1)
    {
        perror("产生标准key错误!\n");
        exit(1);
    }

    qid=msgget(key,IPC_CREAT|0666);        /*创建消息队列*/
    if(qid==-1)
    {
        perror("创建消息队列失败!");
        exit(1);
    }

    while(1)
    {
    /*先利用msgrcv读取demo5-1发送的消息，并添加到标准输出*/
        ret=msgrcv(qid,&msg,sizeof(msg),msg.msg_type,0);
        if(ret==-1)
        {
            perror("读取消息失败!");
            exit(1);
        }
        printf("读取的内容为:\n%s\n",msg.msg_text);

    /*定义写入消息类型为200，并从键盘获取发送内容，利用msgsnd添加消息*/
        msg.msg_type=200;
        printf("请输入发送内容:\n");
        scanf("%s",&msg.msg_text);
        msg.msg_date=system("date|cut -d' ' -f 5");
        ret=msgsnd(qid,&msg,sizeof(msg.msg_text),msg.msg_type);
        if(ret==-1)
        {
            perror("添加消息失败!");
            exit(1);
        }
    }

    msgctl(qid,IPC_RMID,NULL);      /*关闭消息队列*/
    return 0;
}