linux进程通信-消息

最新推荐文章于 2025-01-11 17:17:21 发布
最新推荐文章于 2025-01-11 17:17:21 发布
阅读量841 收藏 1
点赞数
分类专栏： 操作系统 文章标签： linux struct constants buffer file system
消息队列是消息的链接表，包括Posix消息队列system V消息队列。消息队列用于运行于同一台机器上的进程间通信，它
和管道很相似，有足够权限的进程可以向队列中添加消息，被赋予读权限的进程则可以读走队列中的消息。消息队列克服了
信号承载信息量少，管道只能承载无格式字节流以及缓冲区大小受限等缺点。 我们可以用流管道或者套接口的方式来取代它。

查询系统消息队列：ipcs -q

#include <sys/types.h>

#include <sys/ipc.h>

#include <sys/msg.h>

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

int msgget(key_t key, int msgflg);

int msgrcv(int msqid, void *msg_ptr, size_t msg_sz, long int msgtype, int msgflg);

int msgsnd(int msqid, const void *msg_ptr, size_t msg_sz, int msgflg);


C代码
  1. /*msgserver.c*/ 
  2.  
  3. #include <stdlib.h> 
  4. #include <string.h> 
  5. #include <errno.h> 
  6. #include <sys/types.h> 
  7. #include <sys/ipc.h> 
  8. #include <sys/msg.h> 
  9. #include <sys/stat.h> 
  10.  
  11. #define   MSG_FILE "msgserver.c" 
  12. #define   BUFFER 255  
  13. #define   PERM S_IRUSR|S_IWUSR 
  14. /* 服务端创建的消息队列最后没有删除,我们要使用ipcrm命令来删除的 */ 
  15. /* ipcrm -q <msqid> */ 
  16.  
  17. struct msgtype  
  18. {  
  19.     long mtype;  
  20.     char buffer[BUFFER+1];  
  21. };  
  22.  
  23. int main()  
  24. {  
  25.     struct msgtype msg;  
  26.     key_t key;  
  27.     int msgid;  
  28.      
  29.     if((key=ftok(MSG_FILE,'a'))==-1)  
  30.     {  
  31.         fprintf(stderr,"Creat Key Error:%s\n", strerror(errno));  
  32.         exit(1);  
  33.     }  
  34.  
  35.     if((msgid=msgget(key, PERM|IPC_CREAT|IPC_EXCL))==-1)  
  36.     { 
  37.         fprintf(stderr, "Creat Message Error:%s\n", strerror(errno));  
  38.         exit(1); 
  39.     }  
  40.     printf("msqid = %d\n", msgid); 
  41.     while(1) 
  42.     {  
  43.         msgrcv(msgid, &msg, sizeof(struct msgtype), 1, 0);  
  44.         fprintf(stderr,"Server Receive:%s\n", msg.buffer);  
  45.         msg.mtype = 2;  
  46.         msgsnd(msgid, &msg, sizeof(struct msgtype), 0);  
  47.     }  
  48.     exit(0);  
  49. }    
C代码
  1. /* msgclient.c */ 
  2.  
  3. #include <stdio.h> 
  4. #include <stdlib.h> 
  5. #include <string.h> 
  6. #include <errno.h> 
  7. #include <sys/types.h> 
  8. #include <sys/ipc.h> 
  9. #include <sys/msg.h> 
  10. #include <sys/stat.h> 
  11.  
  12. #define   MSG_FILE "msgserver.c" 
  13. #define   BUFFER 255  
  14. #define   PERM S_IRUSR|S_IWUSR 
  15.  
  16. struct msgtype {  
  17.     long mtype;  
  18.     char buffer[BUFFER+1];  
  19. };  
  20.  
  21. int main(int argc,char **argv)  
  22. {  
  23.     struct msgtype msg;  
  24.     key_t key;  
  25.     int msgid;  
  26.      
  27.     if(argc != 2)  
  28.     {  
  29.         fprintf(stderr,"Usage:%s string\n", argv[0]);  
  30.         exit(1);  
  31.     }  
  32.      
  33.     if((key=ftok(MSG_FILE,'a'))==-1)  
  34.     {  
  35.         fprintf(stderr,"Creat Key Error:%s\n", strerror(errno));  
  36.         exit(1);  
  37.     }  
  38.      
  39.     if((msgid=msgget(key, PERM))==-1)  
  40.     {  
  41.         fprintf(stderr,"Creat Message  Error:%s\n", strerror(errno));  
  42.         exit(1);  
  43.     }  
  44.      
  45.     msg.mtype = 1;  
  46.     strncpy(msg.buffer, argv[1], BUFFER);  
  47.     msgsnd(msgid, &msg, sizeof(struct msgtype), 0);   
  48.     memset(&msg, '\0',sizeof(struct msgtype));  
  49.     msgrcv(msgid, &msg, sizeof(struct msgtype), 2, 0);  
  50.     fprintf(stderr, "Client receive:%s\n", msg.buffer);  
  51.     exit(0); 
  52. }   




posix消息：

消息队列可以当做一个消息链表，不同于FIFO和管道，某个进程往一个消息队列写入消息之前，不需要另外进程在该队列上等待消息的到达。

对posix消息队列的读总是返回最高优先级的最早消息。

常用函数：

创建或者打开一个消息队列：

       #include <fcntl.h>           /* For O_* constants */
       #include <sys/stat.h>        /* For mode constants */
       #include <mqueue.h>

       mqd_t mq_open(const char *name, int oflag);
       mqd_t mq_open(const char *name, int oflag, mode_t mode,

                     struct mq_attr *attr);

关闭消息队列：

       #include <mqueue.h>

       int mq_close(mqd_t mqdes);
删除消息队列:

posix消息队列具备随内核的持续性，就是说即使当前没有进程打开某个消息队列，该队列上的消息也将一直存在。

       #include <mqueue.h>

       int mq_unlink(const char *name);

要真正的删除一个消息队列得这样：调用mq_unlink并让它的引用计数（close一次减少1）达到0。

获取消息队列属性：

       #include <mqueue.h>

 

       int mq_getattr(mqd_t mqdes, struct mq_attr *attr);

 

       int mq_setattr(mqd_t mqdes, struct mq_attr *newattr,

                        struct mq_attr *oldattr);

其中消息队列属性结构体如下：
           struct mq_attr {
               long mq_flags;       /* Flags: 0 or O_NONBLOCK */
               long mq_maxmsg;      /* Max. # of messages on queue */
               long mq_msgsize;     /* Max. message size (bytes) */
               long mq_curmsgs;     /* # of messages currently in queue */
           };

接收和发送消息：
       #include <mqueue.h>

       int mq_send(mqd_t mqdes, const char *msg_ptr,
                     size_t msg_len, unsigned msg_prio);
       #include <mqueue.h>

       ssize_t mq_receive(mqd_t mqdes, char *msg_ptr,
                          size_t msg_len, unsigned *msg_prio);


消息队列限制：
总共有四个限制，分别为：
mq_mqxmsg;mq_msgsize;
MQ_OPEN_MAX;MQ_PRIO_MAX:这两个是在<unistd.h>头文件里定义的，可以用sysconf获取。


例子：创建消息队列
代码：
1//mqcreate.c
01#include <stdio.h>
02#include <stdlib.h>
03#include <unistd.h>
04#include <mqueue.h>
05#include <fcntl.h>
06#include <sys/stat.h>
07#define FILEMODE (S_IRUSR | S_IWUSR | S_IRGRP |S_IWGRP)
08struct mq_attr attr;//消息队列属性结构体
09 
10int main(int argc, char **argv)
11{
12    int c, flags;
13    mqd_t mqd;
14 
15    flags = O_RDWR | O_CREAT;
16    while((c = getopt(argc, argv, "em:z:")) != -1) {//处理参数，带冒号的表示后面有参数的
17        switch(c) {
18            case 'e':
19                flags |= O_EXCL;
20                printf("the optind is :%d\n",optind);
21                break;
22            case 'm':
23                attr.mq_maxmsg = atol(optarg);
24                printf("the optind is :%d\n",optind);
25                break;
26            case 'z':
27                attr.mq_msgsize = atol(optarg);
28                printf("the optind is :%d\n",optind);
29                break;
30        }
31    }
32    if (optind != argc - 1) {
33        printf("usage: mqcreate [-e] [-m maxmsg -z msgsize] <name>");
34        exit(0);
35    }
36     
37    if ((attr.mq_maxmsg != 0 && attr.mq_msgsize == 0) || (attr.mq_maxmsg == 0 && attr.mq_msgsize !=0)){
38        printf("must specify both -m maxmsg and -z msgsize");
39        exit(0);
40    }
41 
42    mqd = mq_open(argv[optind], flags, FILEMODE, (attr.mq_maxmsg != 0) ? &attr : NULL);
43    mq_close(mqd);
44    exit(0);
45}

例子：发送消息
代码：
1//mqsend.c
01#include <stdio.h>
02#include <stdlib.h>
03#include <unistd.h>
04#include <mqueue.h>
05 
06 
07int main(int argc, char **argv)
08{
09    mqd_t mqd;
10    void *ptr;
11    size_t len;
12    unsigned int prio;
13 
14    if (argc != 4) {
15        printf("usage: mqsend <name> <#bytes> <priority>");
16        exit(0);
17    }
18    len = atoi(argv[2]);
19    prio = atoi(argv[3]);
20     
21    if ((mqd = mq_open(argv[1], O_WRONLY)) == -1){
22        printf("open error");
23        exit(0);
24    }
25    ptr = calloc(len, sizeof(char));
26    mq_send(mqd, ptr, len, prio);
27    exit(0);
28}

例子：读取一个消息
代码：
1//mqrecieve.c
01#include <stdio.h>
02#include <stdlib.h>
03#include <unistd.h>
04#include <mqueue.h>
05 
06int main(int argc, char **argv)
07{
08    int c, flags;
09    mqd_t mqd;
10    ssize_t n;
11    unsigned int prio;
12    void *buff;
13    struct mq_attr attr;
14    flags = O_RDONLY;
15    while((c = getopt(argc, argv, "n")) != -1){
16        switch(c) {
17            case 'n':
18                flags |= O_NONBLOCK;
19                break;
20        }
21    }
22    if (optind != argc-1) {
23        printf("usage: mqreceive [-n] <name>");
24        exit(0);
25    }
26 
27    mqd = mq_open(argv[optind], flags);
28    mq_getattr(mqd, &attr);
29 
30    buff = malloc(attr.mq_msgsize);
31 
32    n = mq_receive(mqd, buff, attr.mq_msgsize, &prio);
33    printf("read %ld bytes, priority = %u\n",(long) n,prio);
34    exit(0);
35}

Linux 进程通信 -- 管道
Once_fish_的博客
04-17 1845
1、管道简介 管道是Linux提供的进程间通信机制之一，允许通信进程之间通过文件读写的方式单向传递数据。内核实现的文件系统pipefs，会在内核为每个管道文件分配一个的环形缓存区，以支持读/写操作。进程可以使用两种类型的管道进行通信： 匿名管道：只支持在父子进程、兄弟进程之间通信。一般使用方式为，父进程调用pipe()创建匿名管道，fork()的子进程默认继承父进程打开的管道 命名管道：支持任意的进程通过管道通信。进程通信前，需要先创建fifo类型特殊的文件，然后读写进程分别打开该文件进行读写 2、
Linux下进程间的通信--消息队列
2301_79695216的博客
08-24 1659
在Linux系统中，消息队列是一种进程间通信（IPC）机制，允许不同进程向队列中添加消息，其他进程可以从队列中读取消息。消息队列可以跨多个进程共享，支持多种数据类型，并且可以设置消息优先级。消息队列具有FIFO的特性，具有无名管道与有名管道各自的优势，可以支持任意两个进程的进程间通讯
Linux 进程之间的通信
qq_43403759的博客
03-19 310
文章目录一.进程通信的必要性1.数据传输2.数据传输3.通知事件4.进程控制二.进程通信的方式1.管道2.消息队列（message）3.信号（signal）4.共享内存5.信号量（semaphore）6.套接字（socket）三.注意事项 一.进程通信的必要性   进程的数据空间是独立的，私有的，不能互相访问，但是在某些情况下进程之间需要通信来实现某些功能或交换数据。比如 1.数据传输   数据传输：一个进程需要将它的数据发送给另一个进程。 2.数据传输   共享数据：多个进程想要操作共享数据，一个进程对
linux一个进程通知另外一个进程,Linux系统进程管理介绍
weixin_35370032的博客
04-28 393
微软系统的进程管理，无法就是打开任务管理器，查看进程、结束进程、或者创建进程。但是在Linux系统中进程管理是一件比较复杂的工作了。本文就来详细介绍一下Linux系统进程管理。普通调度算法FCFSFirst Come First Service。FIFO方式的调度策略，先来后到的服务方式。这种方式的优势是实现简单，也是最容易想到的调度方案。但是有两个重大问题：1.对短进程的运行不利短进程必须等到前...
linux进程间通知,Linux进程间的关系详解
weixin_42367557的博客
04-28 177
Linux的进程相互之间有一定的关系。比如说，在Linux进程基础中，我们看到，每个进程都有父进程，而所有的进程以init进程为根，形成一个树状结构。我们在这里讲解进程组和会话，以便以更加丰富的方式了管理进程。进程组 (process group)每个进程都会属于一个进程组(process group)，每个进程组中可以包含多个进程。进程组会有一个进程组领导进程 (process group le...
linux进程间通信方法
gaosaixing的博客
08-14 373
Linux作为一种新兴的操作系统，几乎支持所有的Unix下常用的进程间通信 方法：管道、消息队列、共享内存、信号量、套接口等等 1、管道  　　 管道是进程间通信中最古老的方式，它包括无名管道和有名管道两种，前者用于父进程和子进程间的通信，后者用于运行于同一台机器上的任意两个进程间的通信。 有关联的进程之间用无名管道，无关联用命名管道； 　　 无名管道由pipe（）函数创建：
S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP 分别是什么意思？
热门推荐
bestkilly的博客
09-01 1万+
open第三个参数一般用法： if((to_fd = open(to, O_WRONLY|O_CREAT, S_IRUSR|S_IWUSR)) == -1) { //db_error("Open %s Error:%s\n", to, strerror(errno)); //close(from_fd); //return -1;
Linux进程间通信--使用信号
09-15
Linux进程间通信是一种让不同进程之间交换信息或协调工作的方式，而在Linux系统中，信号（Signal）是一种简单但重要的通信机制。本文将深入探讨如何利用信号进行进程间通信。 首先，信号是操作系统用来通知进程发生...
Linux进程间通信-消息队列实例.pdf
07-11
【Linux进程间通信-消息队列实例】 在操作系统中，进程间通信（Inter-Process Communication, IPC）是多个进程共享数据、协调工作的重要机制。在Linux系统中，提供了多种进程间通信方式，如管道、信号量、共享内存...
linux-fusion-1.1.tar.gz_fusion_linux fusion_linux 进程 通信_linux-fu
09-20
描述中提到“linux进程间高级通信的一个模块”，这暗示了Linux Fusion可能是一个专注于进程间通信（IPC，Inter-Process Communication）的库或框架。在Linux系统中，进程间通信是不同进程之间交换数据的重要机制，...
linux c s_irusr 在哪个头文件,c – UNIX系统编程中的S_IFMT是什么？
weixin_39715290的博客
05-04 1450
我正在学习系统调用,因此编写了一个代码来使用C语言实现ls.代码有效,但我无法理解它的工作原理val=(mystat.st_mode & ~S_IFMT)在下面给出的代码中？我理解其余的代码.#include #include #include #include #include #include #include int main(int argc, char* argv[]){DIR ...
S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP
u013369907的专栏
01-04 3296
S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP   fd=open("/dev/globalvar", O_RDWR, S_IRUSR|S_IWUSR);     //可读写方式打开设备文件   S_IRUSR Permits the file's owner to read it. S_IWUSR Permits the fil
S_IRUSR S_IWUSR 权限
u013786805的专栏
10-15 1万+
S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP 分别是什么意思？ S_IRUSR   Permits the file's owner to read it. S_IWUSR   Permits the file's owner to write to it. S_IRGRP   Permits the file's group
linux 内核模块传参
a13698709128的博客
03-18 334
头文件在“include/linux/moduleparam.h”• 内核模块可以通过module_param来传单个参数– module_param(name,type,perm)– name：模块参数的名称– type： 模块参数的数据类型（支持int long short uint ulong ushort类型）– perm： 模块参数的访问权限（S_IRUSR参数表示所有文件所有者可读）传...
linux C/C++文件路径操作
pj_wxyjxy的博客
04-06 1413
linux c++ 文件夹操作
Linux系统编程-文件基本操作
最新发布
Are_pro_bald的博客
01-11 1089
在Linux中，几乎所有事物都能被视为文件，文件不仅仅是存储数据的容器，它还包括了程序、设备、目录等各种资源。要使用Linux，就需要学习文件的基本操作，本文讲解了Linux系统开发时的一些函数，并与C语言标准库函数有所对比，展示了系统IO与标准IO的优劣
linux文件编程_文件
2301_79405674的博客
10-01 1510
Linux文件编程是指在Linux操作系统下，使用编程语言提供的接口对文件进行操作的过程。这包括创建、读取、写入、修改和删除文件等操作。
UNIX环境高级编程（第4章 文件和目录）
瓦釜苑
09-29 904
文件类型，文件访问权限，文件模式创建屏蔽字
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值