linux进程间通信-IPC（管道）

最新推荐文章于 2024-08-01 16:15:20 发布
最新推荐文章于 2024-08-01 16:15:20 发布
阅读量443 收藏
点赞数 2
分类专栏： linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/PNUHC/article/details/92079653
版权

1.匿名管道pipe

2.命名管道mkfifo

1.匿名管道pipe

  • 管道是半双工的，数据只能向一个方向流动；需要双方通信时，需要建立起两个管道;
  • 只能用于父子进程或者兄弟进程之间(具有亲缘关系的进程);
  • 单独构成一种独立的文件系统：管道对于管道两端的进程而言，就是一个文件，但它不是普通的文件，它不属于某种文件系统，而是自立门户，单独构成一种文件系统，并且只存在与内存中;
  • 数据的读出和写入：一个进程向管道中写的内容被管道另一端的进程读出。写入的内容每次都添加在管道缓冲区的末尾，并且每次都是从缓冲区的头部读出数据。
(1) 测试一下管道的大小:
#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>
#include<string.h>
#include<errno.h>

int main()
{
  int fd[2];
  int count = 0;
  
  if(pipe(fd)<0)
  {
    perror("Fail to create pipe");
    exit(EXIT_FAILURE);
  }

  while(1)
  {
    write(fd[1],"a",sizeof(char));
    printf("count = %d.\n",++count);
  }
  return 0;
}

结果如下：
在这里插入图片描述
单独创建一个无名管道，并没有实际的意义。我们一般是在一个进程在由pipe()创建管道后，一般再由fork一个子进程，然后通过管道实现父子进程间的通信(因此也不难推出，只要两个进程中存在亲缘关系,这里的亲缘关系指的是具有共同的祖先，都可以采用管道方式来进行通信）

（2）从管道中读写数据
A.通过标准输入stdin给管道里输入数据并且通过标准输出读取管道中的数据
#include<unistd.h>
#include<stdio.h>
#include<string.h>
#include<errno.h>
#include<stdlib.h>

#define N 10
#define MAX 100

int child_read_pipe(int fd)
{
  char buf[N];
  int n = 0;
  while(1)
  {
    n = read(fd,buf,sizeof(buf));//从fd文件中读取（整个buf的size：sizeof(buf)）数据到buf
    buf[n] = '\0';				 //sizeof(数组名)计算的是整个数组的大小

    printf("read %d bytes:%s.\n",n,buf);

    if(strncmp(buf,"quit",4)==0)//如果读到的是quit 则结束循环
      break;
  }
return 0;
}


int parent_write_pipe(int fd)
{
 char buf[MAX] = {0};

 while(1)
 {
   printf(">");
   fgets(buf,sizeof(buf),stdin);//从stdin（标准输入文件（键盘输入））读取数据到buf
   buf[strlen(buf)-1] = '\0';  给读取完的buf最后的字符加上\0，作为字符串的结束标志，用于strlen(buf)
   write(fd,buf,strlen(buf));//将buf（实际大小strlen(buf)）的数据写入到fd文件中去
   usleep(500);

  if(strncmp(buf,"quit",4)==0)//如果写入的是quit 则结束循环
    break;
 }
 return 0;
}


int main()
{
  int pid;
  int fd[2];

  if(pipe(fd)<0)
  {
    perror("Fail to pipe");
    exit(EXIT_FAILURE);
  }

  if((pid = fork())<0)
  {
    perror("Fail to fork");
    exit(EXIT_FAILURE);
  }
  else if(pid == 0)
  {
    close(fd[1]);//子进程用于读，则关闭写段
    child_read_pipe(fd[0]);
  }
  else 
  {
    close(fd[0]);//父进程用于写，则关闭读端
    parent_write_pipe(fd[1]);
  }
  exit(EXIT_SUCCESS);
}

输出结果：
在这里插入图片描述

从以上验证我们可以看到：
<1>当写端存在时，管道中没有数据时，读取管道时将阻塞
<2>当读端请求读取的数据大于管道中的数据时，此时读取管道中实际大小的数据
<3>当读端请求读取的数据小于管道中的数据时，此时放回请求读取的大小数据

B.通过读取文件中的数据到管道，并且通过管道输出到另一个新文件中去
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/wait.h>

#define MAX 100

int child_work(int pfd,char *fname)//创建文件fname，并且从管道pfd读数据到该文件中去
{
    int n,fd;
    char buf[MAX];

    if((fd = open(fname,O_WRONLY | O_CREAT | O_TRUNC,0666)) < 0)//创建新文件并打开
    {
        fprintf(stderr,"Fail to open %s : %s.\n",fname,strerror(errno));
        return -1;
    }

    while( n = read(pfd,buf,sizeof(buf)) )//将数据从管道读到buf中
    {
        write(fd,buf,n);//将buf中的数据写入到fd文件中去
    }
    
    close(pfd);
    close(fd);

    return 0;
}

int father_work(int pfd,char *fname)//从fname文件中读取数据到管道pfd
{
    int fd,n;
    char buf[MAX];

    if((fd = open(fname,O_RDONLY)) < 0)//打开已经存在的fname文件
    {
        fprintf(stderr,"Fail to open %s : %s.\n",fname,strerror(errno));
        return -1;
    }

    while(n = read(fd,buf,sizeof(buf)))//从fname文件中读取数据到buf中
    {
        write(pfd,buf,n);//将buf中的数据写入到pfd管道中
    }
    
    close(pfd);
    close(fd);

    return 0;
}

int main()
{
    int pid;
    int fd[2];

    if(pipe(fd) < 0)
    {
        perror("Fail to pipe");
        exit(EXIT_FAILURE);
    }

    if((pid = fork()) < 0)
    {
        perror("Fail to fork");
        exit(EXIT_FAILURE);
    
    }else if(pid == 0){
        
        close(fd[1]);
        child_work(fd[0],"pipe_read");
    
    }else{
    
        close(fd[0]);
        father_work(fd[1],"pipe_write");
        wait(NULL);
    }

    exit(EXIT_SUCCESS);
}
//注意：文件中使用了两个buf：是管道和文件链接的媒介

输出结果：
在这里插入图片描述

2.命名管道mkfifo

  • 匿名管道应用的一个限制就是只能在具有共同祖先（具有亲缘关系）的进程间通信。

  • 如果我们想在不相关的进程之间交换数据，可以使用FIFO文件来做这项工作，它经常被称为命名管道。

  • 命名管道可以从命令行上创建，命令行方法是使用下面这个命令：

$ mkfifo filename

  • 命名管道也可以从程序里创建，相关函数有：

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

A.程序使用mkfifo函数创建一个命名管道文件test.fifo，将Makefile 的文件都读取到test.fifo文件中

mkfifo_write.c

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

int main()
{
  //管道操作
  umask(0);
  int ret;
  ret = mkfifo("./test.fifo",0664);
  if(ret < 0)
  {
    perror("mkfifo error");
    exit(EXIT_FAILURE);
  }

  //管道文件操作
  int fd;
  printf("start open ----------\n");
  fd = open("./test.fifo",O_WRONLY,0664);
  printf("end open ----------\n");
  if(fd < 0)
  {
    perror("open error");
    exit(EXIT_FAILURE);
  }
  printf("./test.fifo open success\n");

  //管道写数据
  while(1)
  {
    char buf[10] = {0};
    printf("I say:");
    fflush(stdout);
    scanf("%s",buf);
    //write("./test.fifo",buf,strlen(buf));
    write(fd,buf,strlen(buf));
  }

  close(fd);
  
  return 0;
}

mkfifo_read.c

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

int main()
{
    umask(0);
    int ret = mkfifo("./test.fifo", 0664);
    if (ret < 0) {
        if (errno != EEXIST) {
            perror("mkfifo error");
            return -1;
        }
    }

    printf("start open -------\n");
    int fd = open("./test.fifo", O_RDONLY);
    printf("end open -------\n");
    if (fd < 0) {
        perror("open error");
        return -1;
    }
    printf("fifo:%s open success!!\n", "./test.fifo");

    while(1) {
        sleep(5);
        char buf[10] = {0};
        read(fd, buf, 9;
        printf("peer say: %s\n", buf);
    }
    close(fd);
    return 0;
}

写入端输出结果：
在这里插入图片描述
输出端输出结果：
在这里插入图片描述

B.创建管道将一个文件中的数据拷贝到另一个文件中：

(1) 首先通过命令创建管道（也可通过函数mkfifo）

在这里插入图片描述

(2) 写两个文件：mkfifo_read.c 和 mkfifo_write.c

mkfifo_read.c

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

//这个代码是  将makefile文件里的数据写入到管道文件(test.fifo)中去
int main()
{

  //以只读的方式打开makefile文件
  int infd;
  infd = open("makefile",O_RDONLY);
  if(infd == -1)
  {
    perror("open error");
    exit(EXIT_FAILURE);
  }
  printf("open makefile success\n");

  //以只写的方式打开管道test.fifo
  int outfd;
  outfd = open("test.fifo",O_WRONLY);
  if(outfd == -1)
  {
    perror("open error");
    exit(EXIT_FAILURE);
  }
  printf("open test.fifo success\n");

  //通过字符数组buf，将文件makefile里的数据写入管道
  char buf[1024];
  int n;
  while((n = read(infd,buf,1023))>0)
  {
    write(outfd,buf,strlen(buf));
  }

  //最后别忘记关闭两个文件：makefile文件 和 管道文件
  close(infd);
  close(outfd);

  return 0;
}

mkfifo_write.c

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<fcntl.h>
#include<string.h>
#include<sys/stat.h>
#include<signal.h>
#include<errno.h>

//这个代码是 将管道(test.fifo)中的文件写入到新文件makefile2中去

int main()
{
  umask(0);
  //首先以可写方式创建并打开新文件makefile2
  int outfd;
  outfd = open("makefile2",O_WRONLY|O_CREAT|O_TRUNC,0664);
  if(outfd == -1)
  {
    perror("open error");
    exit(EXIT_FAILURE);
  }
  printf("create makefile2 success\n");

  //然后以可读方式打开管道
  int infd;
  infd = open("test.fifo",O_RDONLY);
  if(infd == -1)
  {
    perror("open error");
    exit(EXIT_FAILURE);
  }
  printf("open test.fifo success\n");

  //最后借助字符数组buf，将管道中的数据写入到makefile2文件中
  char buf[1024];
  int n;
  while((n = read(infd,buf,1023))>0)
  {
    write(outfd,buf,strlen(buf));
  }

  //关闭两个文件：makefile2文件 和 管道文件
  close(infd);
  close(outfd);

  unlink("test.fifo");
  return 0;
}

(3) 再写一个makefile文件

all: mkfifo_write mkfifo_read 
mkfifo_write:mkfifo_write.c
	gcc $^ -o $@
mkfifo_read:mkfifo_read.c
	gcc $^ -o $@

(4) 然后运行读取程序 会阻塞在这一步

在这里插入图片描述

(5) 阻塞时在另一个终端运行写入文件程序

在这里插入图片描述

原终端读取程序不再阻塞，运行成功
在这里插入图片描述
文件通过管道拷贝成功

PHONER'S NUHC
关注
专栏目录
进程间通信（IPC）--------- 管道
chaun的博客
09-03 268
１、管道是一个进程连接数据流到另一个进程的通道，它通常把一个进程的输出通过管道连接到另一个进程的输入，如要列出当前文件下所有命名中有"test"的文件：ls -l | grep test。其中"|"就代表我们在使用管道，它会把"ls -l"的查询结果通过管道，发送给grep，然后执行"grep test"命令后把结构输出到终端。(1)只能用于具有亲缘关系的进程，父子进程、兄弟进程之间(进程描述符在父进程中创建，子进程能够继承，多个子进程均继承后可以互相通信)(5)基于队列实现，有大小限制。
【C++服务器入门基础------4.IPC进程间通信--管道】
qq_39583373的博客
02-22 1703
c++服务器入门系列 大学生寒假在家里过于无聊，整理一下以前学过的知识，顺便复习一下，水平较低，专业性不强，仅供参考。
Linux pipe函数
热门推荐
MyArrow的专栏
06-06 8万+
1. 函数说明 pipe（建立管道）： 1) 头文件 #include 2) 定义函数： int pipe(int filedes[2]); 3) 函数说明： pipe()会建立管道，并将文件描述词由参数filedes数组返回。               filedes[0]为管道里的读取端               filedes[1]则为管道的写入端。 4) 返回值：  若成
Linux IPC 之管道
Magnum的博客
03-24 344
Linux编程之pipe()函数
北芒的博客
06-13 602
管道是一种把两个进程之间的标准输入和标准输出连接起来的机制，从而提供一种让多个进程间通信的方法，当进程创建管道时，每次都需要提供两个文件描述符来操作管道。其中一个对管道进行写操作，另一个对管道进行读操作。对管道的读写与一般的IO系统函数一致，使用write()函数写入数据，使用read()读出数据。 #include<unistd.h> int pipe(int filedes[2]); 返回值：成功，返回0，否则返回-1。参数数组包含pipe使用的两个文件的描述符。fd[0]:读管道，fd[1
Linux进程之间的通讯（IPC）--管道
baidu_39594043的博客
08-31 208
进程间通讯介绍（IPC）： IPC的方式通常有管道（包括无名管道和命名管道）、消息队列、信号量、共享存储、Socket、Streams等。其中 Socket和Streams支持不同主机上的两个进程IPC。 一、管道 1.无名管道 管道，通常指无名管道，是 UNIX 系统IPC最古老的形式。 1.1 特点： （1）管道建立内核的内存中的，父进程与子进程退出后，这个管道就消失了，不会在磁盘中存在； （2）它是半双工的（即数据只能在一个方向上流动）； （3）它只能用于具有亲缘关系的进程之间的通信（也是父子进程或者
Linux进程间通信-命名管道实例.pdf
07-11
在给定的文件“Linux进程间通信-命名管道实例.pdf”中，我们可以通过两个示例程序来理解命名管道的工作原理。 首先，我们来看写操作程序。这个程序主要负责向命名管道写入数据。在程序中，定义了一个常量`FIFO_...
linux系统编程--进程间通信--管道
08-21
常用的进程间通信方式有多种，包括无名管道、有名管道、信号、System V IPC 对象共享内存、消息队列和信号灯、BSD 套接字等。 本文主要介绍无名管道（pipe）的概念和使用方法。无名管道是一种半双工的通信方式，...
Linux进程间通信-信号量通信进程互斥实例.pdf
07-11
【Linux进程间通信】在操作系统中，进程间通信（Inter-Process Communication, IPC）是不同进程之间交换数据的重要机制。Linux提供了多种IPC方式，包括管道、消息队列、共享内存、信号量等。本实例主要关注的是...
深入理解Linux进程间通信IPC -- 管道，共享内存，消息队列，信号量
ifwecande的博客
07-21 669
文章目录进程间通信管道匿名管道命名管道共享内存消息队列信号量 进程间通信 每个进程都有自己独立的虚拟地址内存空间，因此不同的进程具有独立性，一般情况下，是不会互相影响的。但是不同进程经常需要进行数据传输或者数据共享等一些操作。 于是便引出了进程间通信IPC这个概念。 进程间通信的作用和目的： 数据传输：一个进程需要将它的数据发送给另一个进程，发送的数据量在一个字节到几兆字节之间。 共享数据：多个进程想要操作共享数据，一个进程对共享数据的修改，别的进程应该立刻看到。 通知事件：一个进程需要向另一个
Linux：进程间通信IPC 管道
Tina14的博客
01-29 1477
进程间通信IPC：管道(有名管道，无名管道)，信号量，共享内存，消息队列，套接字（不在统一主机上） 管道：两个进程同时打开，且必须是一读一写。打开管道用open，只有两个一个读一个写才同意打开，否则不打开。管道写（管道满，写阻塞）入数据write，读管道（管道为空，读阻塞）read从内存中读，写。管道使用结束要close。管道有大小。 管道：fifo 无名管道：pipe（int fd[]）,fd[0]读 fd[1]写 1.有名和无名的区别？有名可以在任意两个进程间通信，无名指能在父子进程通信 2.
linux---进程间通信(ipc)之管道
boke_fengwei
04-18 206
进程间通信方式 管道 共享内存 消息队列 信号量 本地套接字等等都能作为我们进程间通信的方法 操作系统提供进程间通信方式的原因 因为对于我们进程来说，每一个进程都是相互独立的，具有独立性，如果我们需要两个不同的进程相互通信，就需要我们操作系统提供一个公共的媒介，这个媒介就是进程间通信方式 进程间通信是干什么的？ 通过进程间通信我们可以对不同进程进行数据传输，数据共享，进程控制，时间通知，...
Linux:IPC之管道
CoolSuperman的博客
04-21 234
文章目录管道匿名管道模拟实现以下操作：ls | grep make命名管道模拟实现传输一串字符到另一进程中管道读写特性总结 在这里，我们第一次提到了IPC(Inter-process communication)即进程间通信，我们变来简单说说IPC以及它的使用意义: 在操作系统中，进程间通信主要是为了应对以下场景而产生的: 数据传输:一个进程需要将他的数据发送给另一个进程 数据共享:一份数据有...
IPC之管道
chirrupy_hamal的博客
03-15 605
一个进程通过系统调用 pipe 创建出一个匿名管道，操作系统就会在内核中创建一块没有明确标识的缓冲区，并返回给创建进程两个文件描述符作为管道的操作句柄供进程来操作管道，一个描述符用于从管道中读，另一个用于往管道中写。其中，fd[0]表示读端，fd[1]表示写端。因此匿名管道只能用于具有亲缘关系的进程间通信，因为子进程能复制父进程的文件描述符表。4、进程退出，匿名管道被释放，也就是匿名管道的生命周期随进程，这里的进程指持有匿名管道的最后一个进程，当然也可以主动关闭所有进程的有关匿名管道的那两个文件描述符。
Linux IPC进程间通信(一)：管道
Worthy_Wang的博客
05-18 336
文章目录前言一.标准管道流二.无名管道三.命名管道 前言 Linux进程间通信（IPC）的一个重要方法就是管道，在学习管道之前，要理解两个概念 半双工（读端与写端必须固定） 全双工（读端与写端不固定） 不论是无名管道还是有名管道，都属于半双工管道，理解这一点非常重要。 一.标准管道流 FILE *popen(const char *__command, const char *__modes) command 代表shell指令 modes 分为 "r"读 和 "w"写 具体功能和Linux命令中的
Linux 进程间通讯方式 pipe（）函数
顾修忠的博客
04-19 2万+
Linux 进程间通讯方式有以下几种： 1-》管道(pipe)和有名管道（fifo）. 2-》消息队列 3-》共享内存 4-》信号量 5-》信号(signal) 6-》套接字(sicket) 在这里我们看一下第一种====管道(pipe)。有名管道（fifo）见其它文章。 eg :我们以前学的命令 cat  file | grep  "abc"  > file2 在我看来 我们把
Linux IPC解析：匿名命名管道与共享内存
最新发布
喜欢就坚持吧
08-01 1192
进程间通信）是计算机系统中不同进程之间交换数据和同步操作的机制。由于现代计算机系统中，程序通常会由多个进程组成，这些进程可能需要相互通信以完成任务，因此IPC非常重要。数据交换：允许不同进程共享数据或传递信息。同步：协调多个进程之间的操作，以避免竞态条件和资源冲突。互斥：控制多个进程对共享资源的访问，确保同一时间只有一个进程能够访问资源管道（Pipes）：匿名管道：用于相关进程之间的单向通信，如父子进程或兄弟进程。
Linux 进程间通信（IPC）（pipe，Signal，Semaphore，Shared Memory，Message Queue，Socket）
Hongwei_1990的博客
05-02 1239
Linux进程间通信方式包括管道（匿名管道和命名管道）、信号、信号量、共享内存、消息队列和套接字等方式。 1、管道 管道是一个进程连接数据流到另一个进程的通道，它通常被用来把一个进程的输出端连接到另一个进程的输入端。在Linux命令中通常用符号|来表示管道。例如： $ ps -ef | grep init 此命令中ps是一个独立的进程，grep也是一个独立的进程，中间的管道把ps原本要输出...
linux编程之pipe()函数
铁头娃
11-21 3176
转自：https://www.cnblogs.com/kunhu/p/3608109.html
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值