Linux进程间通信（上）（管道、消息队列）

最新推荐文章于 2025-01-05 11:38:56 发布
最新推荐文章于 2025-01-05 11:38:56 发布
阅读量478 收藏 1
点赞数
文章标签： linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_45637109/article/details/130056516
版权
本文详细介绍了Linux系统中的进程间通信，重点讲解了管道（无名管道和命名管道）和消息队列。无名管道是半双工的，主要用于父子进程或兄弟进程间的通信；命名管道FIFO则允许无关进程之间通信。消息队列是内核中存储的消息链表，支持消息的随机查询和优先级。文中还提供了创建、发送、接收和控制消息队列的代码示例。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

目录

前言

一、管道

（1）无名管道

（2）命名管道

二、消息队列

       创建消息队列 

        发送消息队列

        读取消息队列

        控制消息队列

        ftok函数

实现消息队列的接收和发送

实现相互发送接收，两者同理

前言

        进程间通信的目的：

        1、数据传输：一个进程需要将它的数据发送给另一个进程
        2、资源共享：多个进程之间共享同样的资源
        3、通知事件：一个进程需要向另一个或一组进程发送消息，通知它（它们）发生了某种事件（如进程终止时要通知父进程）
      4、 进程控制：有些进程希望完全控制另一个进程的执行（如Debug进程），此时控制进程希望能够拦截另一个进程的所有陷入和异常

        进程间通信：IPC（InterProcess Communication）

        IPC的方式通常有管道（包括无名管道和命名管道）、消息队列、信号量、共享存储、Socket、Streams等，其中Socket和Streams支持不同主机上的两个进程IPC。

一、管道

        管道，通常指无名管道，是UNIX系统IPC最古老的形式

        特点：

1、半双工（即数据只能在一个方向流动），具有固定的读端和写端

2、只用于父子进程和兄弟进程之间通信

3、可看成一种特殊的文件，对于它的读写可以使用普通的read、write函数，但它不是普通文件，并不属于任何文件系统，并只存在内存中

4、同一时间，数据只能是单向的，一边读一边写

5、管道的数据，读走就没

  （1）无名管道

NAME
       pipe, pipe2 - create pipe

SYNOPSIS
       #include <unistd.h>

       int pipe(int pipefd[2]);

##int pipefd[2] 定义一个两个元素的数组

            代码实现：

#include<stdio.h>
#include <unistd.h>
#include<string.h>
#include <stdlib.h>

int main ()
{

        int fd[2];


        int pid;
        char readBuf[128]={0};
        if(pipe(fd)==-1){
        printf("creat pipe fail\n");

        }

        pid=fork();

        if(pid<0){
                printf("creat fail\n");
        }else if(pid>0){//进入父进程
                sleep(1);
                printf("this is father\n");
                close(fd[0]);//关闭读端
                write(fd[1],"hello helloo",strlen("hello helloo"));//把数据写入管道
        }else{//进入子进程

                printf("this is child\n");
                close(fd[1]);//关闭写端
                read(fd[0],readBuf,128);//读取缓冲区数据
                printf("%s\n",readBuf);//输出数据


        }


        return 0;

}

执行成功。

（2）命名管道

FIFO，也称为命名管道，它是一种文件类型

        特点：

                1、FIFO可以在无关的进程之间交换数据，与无名管道不同

                2、FIFO有路径名与之关联，它以一种特殊设备文件形式存在于文件系统中

   函数原型：

NAME
       mkfifo - make a FIFO special file (a named pipe)

SYNOPSIS
       #include <sys/types.h>
       #include <sys/stat.h>

       int mkfifo(const char *pathname, mode_t mode);

##第一个参数是创建管道的名字
##第二个参数是创建管道的权限

创建命名管道，代码如下：

 if((mkfifo("./file",0600)==-1) && errno!=EEXIST){
        //若命名管道文件创建失败且管道文件不存在输出错误信息
        printf("mkfifo error\n");
        perror("why");

        }

使用命名管道实现进程间通信

读端：

#include<stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <errno.h>
#include <fcntl.h>

int main(){
        int fd;
        char readBuf[30]={0};
        if((mkfifo("./file",0600)==-1) && errno!=EEXIST){

        printf("mkfifo error\n");
        perror("why");

        }
        fd=open("./file",O_RDONLY);
        int nread=read(fd,readBuf,30);
        printf("have %d ,context is %s\n",nread,readBuf);
        close(fd);
        return 0;
}

写端：

#include<stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <errno.h>
#include<string.h>
#include <fcntl.h>

int main(){
        int fd;
        char *str="hello hello";
        fd=open("./file",O_WRONLY);
        write(fd,str,strlen(str));
        close(fd);
        return 0;
}

二、消息队列

        消息队列，是消息的链接表，存放在内核中，一个消息队列由一个标识符(即队列ID)来标识。

        特点：

        1、消息队列是面向记录的，其中的消息具有特定的格式一级特定的优先级

        2、消息队列独立于发送与接受进程。进程终止时，消息队列及其内容并不会被删除

        3、消息队列可以实现消息的随机查询，消息不一定要以先进先出的次序读取，也可以按消息的类型读取

       创建消息队列 

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>

int msgget(key_t key, int msgflg);

key_t key： 创建新的消息队列
int msgflg: 赋予新消息队列的权限，IPC_CREAT|0777

成功返回队列ID，失败返回-1

        发送消息队列

 #include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>

int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);
成功返回0，失败返回-1

int msqid：            消息队列标识符
const void *msgp：     msgp是一个任何类型的结构体，是消息队列的地址
size_t msgsz：         要发送消息的大小，不含消息类型占用的4个字节，即mtext的长度
int msgflg：           默认写0，当消息队列满时，msgsnd将会阻塞，直到消息能写进消息队列 


const void *msgp的结构体如下：
struct msgbuf{

    long mtype;        //message type,must be>0
    char mtext[128];    //message data
}

        读取消息队列

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>

      
ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp,int msgflg);
成功返回消息数据的长度，失败返回-1

int msqid         :消息队列标识符
void *msgp        :存放消息队列的结构体，结构体类型要与msgsnd函数发送的类型相同
size_t msgsz      : 要接受消息的大小，不含消息类型占用的4个字节
long msgtyp       :要读消息的类型，如写：888
int msgflg        :默认写0：阻塞式接收消息，没有该类型的消息msgrcv函数一直阻塞等待

        控制消息队列

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>

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


int msqid                ：消息队列标识符
int cmd                  ： IPC_RMID删除节点 用的最多
struct msqid_ds *buf     ：NULL

        ftok函数

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

key_t key;
key=ftok(".",1);

第二空参数可以为任意数值

实现消息队列的接收和发送

接收信息：

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include<stdio.h>
      // int msgget(key_t key, int msgflg);
//      int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);

//       ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp,
  //                    int msgflg);


struct msgGet {
               long mtype;       /* message type, must be > 0 */
               char mtext[128];    /* message data */
           };



int main(){
        struct msgGet readBuf;

        int msgId=msgget(0x1234,IPC_CREAT|0777);

        if(msgId==-1){
        printf("creat queue fail\n");
        }

        msgrcv(msgId, &readBuf, sizeof(readBuf.mtext), 888,0);
        printf("context is %s\n",readBuf.mtext);

       
        return 0;

}

发送信息：

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include<stdio.h>
      // int msgget(key_t key, int msgflg);
//      int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);

//       ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp,
  //                    int msgflg);


struct msgSend {
               long mtype;       /* message type, must be > 0 */
               char mtext[128];    /* message data */
           };



int main(){
        struct msgSend sendBuf={888,"this is senddata! haha"};

        int msgId=msgget(0x1234,IPC_CREAT|0777);
        if(msgId==-1){
                printf("creat queue fail\n");
        }


        msgsnd(msgId, &sendBuf, sizeof(sendBuf.mtext),0);
        
        return 0;

}

实现相互发送接收，两者同理

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include<stdio.h>
      // int msgget(key_t key, int msgflg);
//      int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);

//       ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp,
  //                    int msgflg);


struct msgSend {
               long mtype;       /* message type, must be > 0 */
               char mtext[128];    /* message data */
           };



int main(){
        struct msgSend sendBuf={888,"this is senddata! haha"};
        key_t key;
        key=ftok(".",1);

        int msgId=msgget(key,IPC_CREAT|0777);
        if(msgId==-1){
                printf("creat queue fail\n");
        }


        msgsnd(msgId, &sendBuf, sizeof(sendBuf.mtext),0);
        struct msgSend readBuf;
        msgrcv(msgId,&readBuf,sizeof(readBuf.mtext),988,0);
        printf("context is %s\n",readBuf.mtext);

        msgctl(msgId,IPC_RMID,NULL);


        return 0;

}


#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include<stdio.h>
      // int msgget(key_t key, int msgflg);
//      int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);

//       ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp,
  //                    int msgflg);


struct msgGet {
               long mtype;       /* message type, must be > 0 */
               char mtext[128];    /* message data */
           };



int main(){
        struct msgGet readBuf;
        key_t key;
        key=ftok(".",1);
        int msgId=msgget(key,IPC_CREAT|0777);

        if(msgId==-1){
        printf("creat queue fail\n");
        }

        msgrcv(msgId, &readBuf, sizeof(readBuf.mtext), 888,0);
        printf("context is %s\n",readBuf.mtext);

        struct msgGet sendBuf={988,"thank you for reach"};
        msgsnd(msgId,&sendBuf,sizeof(sendBuf.mtext),0);


        msgctl(msgId,IPC_RMID,NULL);
        return 0;

}

锦鲤宝宝
关注
Linux 进程间通信（管道）
2201_75663820的博客
09-22 2257
进程间通信、匿名管道、命名管道 ...
linux进程间通信 管道， 消息队列， 共享内存 信号（一）
weixin_52495715的博客
12-06 990
进程间通信 之前进程之间交换信息的方法只能是经由fork或exec传送打开文件，或者通过文件系统。 下来将说明进程之间相互通信的其他技术—IPC(interProcess Commumication) 进程间通信IPC IPC的方式通常有管道(包括无名管道和命名管道)，消息队列，信号量，共享存储，Socket，Streams等，其中Socket和Streams支持不同主机上的两个进程IPC 一,管道 1.特点 它是半双工的(即数据只能在一个方向上流动)，具有固定的读端和写端 它只能用于具有亲缘关系的进.
Linux消息管道机制
12-16
Linux下的消息队列机制，实现进程间的通信
Linux学习笔记---进程间通信（上）（管道和消息队列）
m0_48789433的博客
01-19 1305
一、管道通信 1.无名管道 #include <unistd.h> int pipe(int pipefd[2]); #define _GNU_SOURCE /* See feature_test_macros(7) */ #include <unistd.h> int pipe2(int pipefd[2], int flags); pipe() 创建一个管道，一个可以使用的单向数据通道 用于进程间通信。 数组 pipefd 用
消息队列及管道
yuanfen139re的专栏
10-10 648
正好用到了，记下来 1. 消息队列 首先要定义符合要求的struct typedef struct{ int msg_type; char msg_data[128]; }MSG_DEF; 先来发送消息 MSG_DEF send_msg; int key=8000, id; id = msgget(key, IPC_CREAT | 0660);//不存在就创
管道、消息队列
sinat_38192416的博客
07-14 842
管道和消息队列的区别 管道（PIPE） 管道通信方式的中间介质是文件，通常称这种文件为管道文件。两个进程利用管道文件进行通信时，一个进程为写进程，另一个进程为读进程。写进程通过写端（发送端）往管道文件中写入信息；读进程通过读端（接收端）从管道文件中读取信息。两个进程协调不断地进行写、读，便会构成双方通过管道传递信息的流水线。 管道分为匿名管道和命名管道。 （1）匿名管道:管道是...
管道及消息队列
Drvrenxu的博客
05-05 377
一、无名通道 局限性：只能父子进程之间进行通信 int pipe（int pipefd[2]） 利用无名通道进行读写数据： #include <stdio.h> #include <stdlib.h> #include <string.h> #include <unistd.h> #include <sys/types.h> #inclu...
Linux进程间通信：消息队列
01-20
消息队列允许一个或多个进程向它写入与读取消息. 　3.管道和命名管道都是通信数据都是先进先出的原则。 　4.消息队列可以实现消息的随机查询，消息不一定要以先进先出的次序读取，也可以按消息的类型读取.比FIFO更...
进程间通信之深入消息队列的详解
01-20
消息队列是操作系统提供的一种进程间通信机制，它允许进程之间通过传递消息的方式进行通信，尤其在多进程环境中，消息队列展现出了其强大的灵活性和实用性。本文将深入讲解消息队列的概念、特点以及相关函数的使用。...
Linux 进程间通信（共享内存+消息队列）
2201_75663820的博客
09-25 1143
进程间通信、共享内存、消息队列，底层原理和接口详解 ...
pipe和消息队列
wyz19891024的专栏
09-25 848
转载自：http://bbs.chinaunix.net/viewthread.php?tid=265266 作者：beginner-bj 请问管道和消息队列有什么不同 管道通信（PIPE） 管道通信方式的中间介质是文件，通常称这种文件为管道文件。两个进程利用管道文件进行通信时，一个 进程为写进程，另一个进程为读进程。写进程通过写端（发送端）往管道文件中写入信息；读进程通过读 端（
Linux编程基础 5.1：管道 5.2：消息队列（学后心得）
m0_58233529的博客
05-23 193
1.Linux进程通信机制： 管道 信号量 消息队列 共享内存 socket通信 2.管道 管道其实质是由内核管理的一个缓冲区 形象地认为管道的两端连接着两个进程： 管道分为： 匿名管道：只能用于有亲缘关系的进程间通信，进程退出后管道会被销毁。 命名管道：命名管道与进程的联系较弱，相当于一个读写内存的接口，进程退出后，命名管道依然存在。 2.1匿名管道 匿名管道的使用流程如下： ①在进程中创建匿名管道，pipe函数； ②关闭进程中不使用的管道端口，close函数； ③在待..
Linux进程间通信——管道和消息队列
漫鱼
05-31 1837
进程间通信 多个进程需要互相配合完成一项任务，称为进程同步，例如公交车问题。 多个进程需要访问共享资源（临界资源），而资源同时只能被一个进程访问，各个进程相互竞争使用资源，称为互斥。例如买票问题。 为什么需要进程间通信： 数据传递 资源共享，多个进程使用一个资源 通知事件，告诉其他进程事件发生 通信方式分类： 管道 System V IPC，消息队列，共享内存，信号量 POSI...
操作系统-进程间的四种通信（共享内存、消息队列、信号、管道）
weixin_64612849的博客
06-17 1495
操作系统-进程间的通信-共享内存-消息队列-信号-管道
Linux进程间通信(管道、消息队列、共享内存、信号、信号量)
zhuguanlin121的博客
04-28 1397
目录1.Linux进程间通信概述2.管道无名管道有名管道（FIFO）消息队列消息队列的通信原理消息队列相关api消息队列收发数据键值生成消息队列移除共享内存信号信号量通信方式总结 1.Linux进程间通信概述 进程间通信（IPC，InterProcess Communication）是指在不同进程之间传播或交换信息。 IPC 的方式通常有管道（包括无名管道和命名管道）、消息队列、共享内存、信号、信号量、Socket、Streams 等。其中 Socket 和 Streams 支持不同主机上的两个进程 IPC
进程间通信方式（管道、消息队列、内存映射区、共享内存等）
JACKSONMHLK的博客
05-28 1396
进程间通信 (Inter-Process Communication, 简写为 IPC) 是两个进程之间进行信息交流的一种机制, 不仅仅会发生在同一主机的两个进程之间, 也可以发生在不同主机的两个进程之间,。 在一台主机上，每个进程的用户地址空间都是独立的，一般而言是不能互相访问的，但内核空间是每个进程都共享的，所以进程之间要通信必须通过内核。Linux内核提供了很多通信方式：管道、消息队列、内存映射区、共享内存、套接字。套接字主要应用于跨网络不同主机间的通信（也可以同一主机）。 1、管道与消息队列
Linux进程间通信（七）：消息队列 msgget()、msgsend()、msgrcv()、msgctl()
weixin_34417200的博客
09-11 946
下面来说说如何用不用消息队列来进行进程间的通信，消息队列与命名管道有很多相似之处。有关命名管道的更多内容可以参阅我的另一篇文章：Linux进程间通信 -- 使用命名管道 一、什么是消息队列 消息队列提供了一种从一个进程向另一个进程发送一个数据块的方法。  每个数据块都被认为含有一个类型，接收进程可以独立地接收含有不同类型的数据结构。我们可以通过发送消息来避免命名管道的同步和阻塞问题。但是消息队...
Linux进程间通信（管道，命名管道/FIFO，消息队列）
sakabu的博客
07-21 1255
它可以看成是一种特殊的文件，对于它的读写也可以使用普通的read、write 等函数。但是它不 是普通的文件，并不属于其他任何文件系统，并且只存在于内存中。创建管道后，数据不知道要怎么走，管道要怎么连接？所以我们要把路“打通”，告诉水要怎么流。由于管道是半双工的，所以两条路不能同时选，避免干扰，要把不用的路给断开。当传入一个数组名字时，sizeof返回整个数组在内存中占用的字节数，而不是数组中存储的实际数据的长度，而strlen会返回字符串"\0"之前的字符串的长度。按照定义的消息结构体接受处理消息
进程间通信详解之管道&&消息队列&&共享内存
最新发布
Lllongroad的博客
01-05 1778
进程间通信
Linux进程间通信：管道、消息队列与共享内存解析
"这篇文档详细介绍了Linux环境下的进程间通信机制，包括管道（无名管道和有名管道）、消息队列、共享内存等方法。Linux作为一款操作系统，支持多种Unix下的进程间通信方式，并且强调了在不同的Unix系统中，移植性...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值