Linux进程学习之：消息队列

以你之姓@ 2023-06-13 11:23 75阅读 0赞

消息队列是一个链式队列

创建消息队列需要用到msgget函数，函数声明在“sys/msg.h”头文件里
函数声明如下：

  1. int msgget(key_t key, int msgflg);

msgget　函数有两个参数，第一个是key，可以传入宏 IPC_PRIVATE或者有ftok函数生成的key值，如果传入的是IPC_PRIVATE宏，消息队列将用于具有亲缘关系的进程间通信，如果是ftok函数生成的key值，则可以用于非亲缘关系的进程间通信，第二个参数是生成的消息队列的读写权限，一般使用0777

下面贴一段生成消息队列的代码

  1. #include <iostream>
  2. #include <sys/msg.h>
  3. #include <stdlib.h>
  5. using namespace std;
  7. int main() {
  9.     int msgid = msgget(IPC_PRIVATE, 0777);
  10.     if ( msgid == -1) {
  12.         cout << "Create msgid failed ..." << endl;
  13.         return -1;
  14.     }
  15.     else
  16.         cout << "Create msgid successfully ..." << endl;
  17.     system("ipcs -q");
  18.     return 0;
  19. }

最后的system(“ipcs -q”)的作用是将系统中所有的消息的队列信息打印出来，包括刚才创建的消息队列

删除消息队列用的msgctl函数，同样声明在“sys/msg.h”头文件中
声明如下：

  1. int msgctl(int msqid, int cmd, struct msqid_ds *buf);

第一个参数是告诉函数要操作的msg对象的id，第二个参数是告诉函数要怎么做，因为我们要删除创建的消息队列，所以传入的IPC_RMID宏，第三个参数直接传入空就可以

贴一个创建之后又删除消息队列的问题

  1. #include <iostream>
  2. #include <sys/msg.h>
  3. #include <stdlib.h>
  5. using namespace std;
  7. int main() {
  9.     int msgid = msgget(IPC_PRIVATE, 0777);
  10.     if ( msgid == -1) {
  12.         cout << "Create msgid failed ..." << endl;
  13.         return -1;
  14.     }
  15.     else
  16.         cout << "Create msgid successfully, msgid = " << msgid <<endl;
  17.     system("ipcs -q");
  18.     // do something ...
  19.     //delete msg
  20.     int ret = msgctl(msgid, IPC_RMID, NULL);
  21.     if (ret == -1) {
  23.         cout << "delete msg failed ..." << endl;
  24.         return -2;
  25.     }
  26.     else
  27.         cout << "delete msg successfully ..." << endl;
  28.     system("ipcs -q");
  29.     return 0;
  30. }

接下来说消息队列的消息发送和接受，消息发送用的msgsnd函数，接受用的是msgrcv函数，两个函数声明分别如下：

  1. int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);
  3. ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp, int msgflg);

1、msgsnd函数第一个参数是消息队列的id，第二个参数是一个指向用户自定义结构体的指针，不过这个结构体必须具有如下格式，第一个是参数类型，必须大于０，第二个是一个字符数组，大小可以自己定，不过也必须大于０：

  1. struct msgbuf {
  3.      long mtype;       /* message type, must be > 0 */
  4.      char mtext[1];    /* message data */
  5. };

msgsnd函数的第三个参数是阻塞标志，０表示阻塞，还有其他的各种标志，可以自己去看

２、msgrcv函数和msgsnd函数的区别是只有第四个参数不一样，第四个参数是意思是当前队列消息的类型，需要明确才可以，如果输入的消息类型有误，程序就会被阻塞

接下来贴一个消息队列发送和接受消息的代码：

  1. #include <iostream>
  2. #include <sys/msg.h>
  3. #include <stdlib.h>
  4. #include <string.h>
  6. using namespace std;
  8. struct msgBuff {
  10.     long type;
  11.     char voltage[124];
  12. };
  14. int main() {
  16.     int msgid = msgget(IPC_PRIVATE, 0777);
  17.     if ( msgid == -1) {
  19.         cout << "Create msgid failed ..." << endl;
  20.         return -1;
  21.     }
  22.     else
  23.         cout << "Create msgid successfully, msgid = " << msgid <<endl;
  24.     system("ipcs -q");
  26.     msgBuff sendBuf, rcvBuf;
  27.     sendBuf.type = 100;
  28.     cout << "please input message: ";
  29.     cin >> sendBuf.voltage;
  30.     msgsnd(msgid, (void *)&sendBuf, sizeof(sendBuf.voltage), 0);
  31.     memset(rcvBuf.voltage, 0, sizeof(rcvBuf.voltage));
  32.     int ret = msgrcv(msgid, (void *)&rcvBuf, sizeof(rcvBuf.voltage), 100, 0);
  33.     if (ret == -1){
  35.         cout << "read rcvBuf failed ..." << endl;
  36.     }
  37.     else {
  39.         cout << "read rcvBuf successfully, rcvBuf = " << rcvBuf.voltage << endl;
  40.     }
  41.     //delete msg
  42.     ret = msgctl(msgid, IPC_RMID, NULL);
  43.     if (ret == -1) {
  45.         cout << "delete msg failed ..." << endl;
  46.         return -2;
  47.     }
  48.     else
  49.         cout << "delete msg successfully ..." << endl;
  50.     system("ipcs -q");
  51.     return 0;
  52. }

运行以上代码，可以实现先往消息队列写入信息，接着从消息队列读取信息

接下来贴一个两个无亲缘关系的进程间通过消息队列通信的代码：

首先是写进程代码：

  1. #include <iostream>
  2. #include <sys/msg.h>
  3. #include <stdlib.h>
  4. #include <string.h>
  5. #include <sys/ipc.h>
  7. using namespace std;
  9. struct msgBuff {
  11.     long type;
  12.     char voltage[124];
  13. };
  15. int main() {
  17.     int key = ftok("./a", 1);
  18.     if (key < 0) {
  20.         cout << "Create key failed" << endl;
  21.         return -1;
  22.     }
  23.     else
  24.         cout << "Create key successfully, key = " << key << endl;
  25.     int msgid = msgget(key, IPC_CREAT | 0777);
  26.     if ( msgid == -1) {
  28.         cout << "Create msgid failed ..." << endl;
  29.         return -1;
  30.     }
  31.     else
  32.         cout << "Create msgid successfully, msgid = " << msgid <<endl;
  33.     system("ipcs -q");
  35.     msgBuff sendBuf;
  36.     sendBuf.type = 100;
  37.     while(1) {
  39.         cout << "please input message: ";
  40.         cin >> sendBuf.voltage;
  41.         msgsnd(msgid, (void *)&sendBuf, sizeof(sendBuf.voltage), 0);
  42.     }
  43.     int ret = msgctl(msgid, IPC_RMID, NULL);
  44.     if (ret == -1) {
  46.         cout << "delete msg failed ..." << endl;
  47.         return -2;
  48.     }
  49.     else
  50.         cout << "delete msg successfully ..." << endl;
  51.     system("ipcs -q");
  52.     return 0;
  53. }

然后是读进程的代码

  1. #include <iostream>
  2. #include <sys/msg.h>
  3. #include <stdlib.h>
  4. #include <string.h>
  5. #include <sys/ipc.h>
  7. using namespace std;
  9. struct msgBuff {
  11.     long type;
  12.     char voltage[124];
  13. };
  15. int main() {
  17.     int key = ftok("./a", 1);
  18.     if (key < 0) {
  20.         cout << "Create key failed" << endl;
  21.         return -1;
  22.     }
  23.     else
  24.         cout << "Create key successfully, key = " << key << endl;
  25.     int msgid = msgget(key, IPC_CREAT | 0777);
  26.     if ( msgid == -1) {
  28.         cout << "Create msgid failed ..." << endl;
  29.         return -1;
  30.     }
  31.     else
  32.         cout << "Create msgid successfully, msgid = " << msgid <<endl;
  33.     system("ipcs -q");
  35.     msgBuff rcvBuf;
  36.     while(1) {
  38.         memset(rcvBuf.voltage, 0, sizeof(rcvBuf.voltage));
  39.         msgrcv(msgid, (void *)&rcvBuf, sizeof(rcvBuf.voltage), 100, 0);
  40.         cout << "read buff:" << rcvBuf.voltage << endl;
  41.     }
  42.     int ret = msgctl(msgid, IPC_RMID, NULL);
  43.     if (ret == -1) {
  45.         cout << "delete msg failed ..." << endl;
  46.         return -2;
  47.     }
  48.     else
  49.         cout << "delete msg successfully ..." << endl;
  50.     system("ipcs -q");
  51.     return 0;
  52. }

运行以上代码：可以实现在写进程写入消息，在读进程读取信息的功能

接下里贴一个可以在server进程和client进程双向通信的代码：

首先是server代码：

  1. #include <iostream>
  2. #include <sys/msg.h>
  3. #include <stdlib.h>
  4. #include <string.h>
  5. #include <sys/ipc.h>
  6. #include <unistd.h>
  8. using namespace std;
  10. struct msgBuff {
  12.     long type;
  13.     char voltage[124];
  14. };
  16. int main() {
  18.     int key = ftok("./a", 1);
  19.     if (key < 0) {
  21.         cout << "Create key failed" << endl;
  22.         return -1;
  23.     }
  24.     else
  25.         cout << "Create key successfully, key = " << key << endl;
  26.     int msgid = msgget(key, IPC_CREAT | 0777);
  27.     if ( msgid == -1) {
  29.         cout << "Create msgid failed ..." << endl;
  30.         return -1;
  31.     }
  32.     else
  33.         cout << "Create msgid successfully, msgid = " << msgid <<endl;
  34.     system("ipcs -q");
  36.     int pid = fork();
  37.     if (pid > 0) {
  39.         msgBuff sendBuf;
  40.         sendBuf.type = 100;
  41.         while(1) {
  43.             cout << "please input message: ";
  44.             cin >> sendBuf.voltage;
  45.             msgsnd(msgid, (void *)&sendBuf, sizeof(sendBuf.voltage), 0);
  46.         }
  47.     }
  48.     else if (pid == 0){
  50.         msgBuff rcvBuf;
  51.         while(1) {
  53.             memset(rcvBuf.voltage, 0, sizeof(rcvBuf.voltage));
  54.             msgrcv(msgid, (void *)&rcvBuf, sizeof(rcvBuf.voltage), 200, 0);
  55.             cout << "server recive: " << rcvBuf.voltage << endl;
  56.         }
  57.     }
  58.     int ret = msgctl(msgid, IPC_RMID, NULL);
  59.     if (ret == -1) {
  61.         cout << "delete msg failed ..." << endl;
  62.         return -2;
  63.     }
  64.     else
  65.         cout << "delete msg successfully ..." << endl;
  66.     system("ipcs -q");
  67.     return 0;
  68. }

然后是client代码：

  1. #include <iostream>
  2. #include <sys/msg.h>
  3. #include <stdlib.h>
  4. #include <string.h>
  5. #include <sys/ipc.h>
  6. #include <unistd.h>
  8. using namespace std;
  10. struct msgBuff {
  12.     long type;
  13.     char voltage[124];
  14. };
  16. int main() {
  18.     int key = ftok("./a", 1);
  19.     if (key < 0) {
  21.         cout << "Create key failed" << endl;
  22.         return -1;
  23.     }
  24.     else
  25.         cout << "Create key successfully, key = " << key << endl;
  26.     int msgid = msgget(key, IPC_CREAT | 0777);
  27.     if ( msgid == -1) {
  29.         cout << "Create msgid failed ..." << endl;
  30.         return -1;
  31.     }
  32.     else
  33.         cout << "Create msgid successfully, msgid = " << msgid <<endl;
  34.     system("ipcs -q");
  36.     int pid = fork();
  37.     if (pid > 0) {
  39.         msgBuff sendBuf;
  40.         sendBuf.type = 200;
  41.         while(1) {
  43.             cout << "please input message: ";
  44.             cin >> sendBuf.voltage;
  45.             msgsnd(msgid, (void *)&sendBuf, sizeof(sendBuf.voltage), 0);
  46.         }
  47.     }
  48.     else if (pid == 0){
  50.         msgBuff rcvBuf;
  51.         while(1) {
  53.             memset(rcvBuf.voltage, 0, sizeof(rcvBuf.voltage));
  54.             msgrcv(msgid, (void *)&rcvBuf, sizeof(rcvBuf.voltage), 100, 0);
  55.             cout << "server recive: " << rcvBuf.voltage << endl;
  56.         }
  57.     }
  58.     int ret = msgctl(msgid, IPC_RMID, NULL);
  59.     if (ret == -1) {
  61.         cout << "delete msg failed ..." << endl;
  62.         return -2;
  63.     }
  64.     else
  65.         cout << "delete msg successfully ..." << endl;
  66.     system("ipcs -q");
  67.     return 0;
  68. }

运行以上代码，可以实现两个非亲缘关系进程间的双向通信，其中server进程写入消息的类型是100，读取消息的类型是200，而client进程读取消息的类型是100，写入消息的类型是200，这样双方就可以正常通信了。

发表评论

表情：
评论列表 （有 0 条评论，75人围观）

还没有评论，来说两句吧...

相关阅读

    相关 Linux进程间通信之POSIX消息队列

    消息队列可认为是一个消息链表，它允许进程之间以消息的形式交换数据。有足够写权限的进程或线程可往队列中放置消息，有足够读权限的进程或线程可从队列中取走消息。每个消息都是一个记录，

    野性酷女野性酷女/ 0 赞/ 395 阅读