【Linux】进程间通信之管道篇

最新推荐文章于 2025-02-15 17:21:00 发布
最新推荐文章于 2025-02-15 17:21:00 发布
阅读量343 收藏 1
点赞数
分类专栏： linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/dove1202ly/article/details/79794021
版权

首先我们来了解一下什么是进程间通信？

进程间通信就如同人与人之间的交流一样，注重方式，各有利弊。通俗点讲进程间通信就是在不同进程之间传播或交换信息，那么，我们都知道进程之间是相互独立的，那么进程间通信的本质就是让两个毫不相干的进程看到同一份资源，那么我们又是如何解决这些矛盾的呢？

我们实现进程间通信的主要目的是什么呢？

1.数据传输：一个进程需要将它的数据发送给另一个进程

2.资源共享：多个进程之间共享同样的资源

3.通知事件：一个进程需要向另一个或者一组进程发送消息，通知它（它们）发生了某种事件（如进程终止要通知父进程）

4.进程控制：有些进程希望完全控制另一个进程的执行，此时控制进程希望进程能够截断另一个进程的所有陷入和异常，并能够及时知道它的状态改变

进程间通信的主要分类

进程间通信主要包括管道, 系统IPC（包括消息队列,信号,共享存储), 套接字(SOCKET)等等

今天，我们先来看一种-------->管道

什么是管道

想想我们生活中的各种管道（比如水管，电缆等），他们是不是都是用来传输某种资源的呢？类比而言，管道是Unix种最古老的进程间通信的方式，我们把从一个进程连接到另一个进程的一个数据流称为一个“管道”。

管道的分类

匿名管道和命名管道

什么是匿名管道

匿名管道是一种最基本的IPC机制

匿名管道的特点

1.只能在具有亲缘关系的进程之间进行通信（通常一个管道由一个进程创建，然后该进程调用fork创建子进程，此后父子进程就可应用该管道了）

2.管道是基于字节流的

3.管道生命周期随进程（进程退出，管道不复存在）

4.内核会对管道操作进行同步与互斥

5.管道是半双工的，数据只能向一个方向流动；需要双方通信时，需要建立两个管道（如下图）


如何创建匿名管道？

功能：创建一个无名管道
头文件：#include<unistd.h>
原型： int pipe(int fd[2]);
参数fd: 文件描述符数组，其中fd[0]表示读端，fd[1]表示写端
返回值:成功返回0，失败返回错误代码

应用实例1：

从键盘上读取数据，写入管道，读取管道，写到屏幕

 #include<stdio.h>                                                                                    
   #include<stdlib.h>
   #include<string.h>
   #include<unistd.h>
   int main()
  {
       int fds[2];
       char buf[100];
       int len;
       if(pipe(fds)==-1)
          perror("make pipe"),exit(1);
       //read from stdin
       while(fgets(buf,100,stdin)){
          len=strlen(buf);
          //write into pipe
           if(write(fds[1],buf,len)!=len){
              perror("write to pipe");
                 break;
          }
          memset(buf,0x00,sizeof(buf));
          //read from pipe
          if((len=read(fds[0],buf,100))==-1){
              perror("read from pipe");
              break;
          }
          //write to stdout
          if(write(1,buf,len)!=len){
              perror("write to stdout");
              break;
          }
      }

结果显示


应用实例2

首先我们先来分析一下怎么用fork来共享管道原理（如图）


代码实现：

 #include<stdio.h>
 #include<unistd.h>
 #include<string.h>
 int main()
 {
    int fd[2];
	if (pipe(fd) == -1){
		perror("error pipe");
	    return 1;
	}
	//father write child read
	pid_t pid = fork();//create child
    if (pid<0){
		perror("error fork");
        return 2;
	}
     //chlid
     else if (pid == 0){
         close(fd[1]);//child close to write
         char arr[128];
         int count = 5;
         while (count--){
             ssize_t ss = read(fd[0], arr, sizeof(arr));
             if (ss>0){
                arr[ss] = '\0';
                printf("father--->child: %s\n", arr);
			 }
             else if (ss == 0){
                 printf("father close write");
                 break;
			 }
             else{
                 perror("error read");
                 break;
			 }
		 }
         close(fd[0]);
	 }
     //father
     else{
		 close(fd[0]);//father close to read
         char *str = "hai,luying";
         int count = 5;
         while (count--){
             write(fd[1], str, strlen(str));
             sleep(1);
		 }
         close(fd[1]);
	 }
     return 0;
 }

结果显示：


管道读写规则

1.当没有数据可读时（read 没有一点数据可读或 write 没有一点空间可以写入，如果disable O_NONBLOCK 则会阻塞，如果enable O_NONBLOCK 则会返回-1，errno = EAGAIN | EWOULDBLOCK 错误。）

（1）O_NONBLOCK bisable：read调用阻塞，即进程暂停执行，一直等到有数据来到为止

  1 #include<stdio.h>
  2 #include<unistd.h>
  3 #include<stdlib.h>
  4 #include<fcntl.h>
  5 int main()
  6 {
  7     int fd[2];
  8     if(pipe(fd)==-1){
  9         perror("pipe error");
 10         exit(EXIT_FAILURE);
 11     }
 12     pid_t pid;
 13     pid=fork();
 14     if(pid==-1){
 15         perror("fork error");
 16         exit(EXIT_FAILURE);
 17     }
 18     if(pid==0){
 19         close(fd[0]);//close to read
 20         sleep(5);
 21         char* str="luying";
 22         int len=strlen(str);
 23         write(fd[1],str,len);
 24         exit(EXIT_SUCCESS);
 25     }                                                                                                
 26     close(fd[1]);//close to write
 27     char buf[20]={0};
 28     read(fd[0],buf,20);
 29     printf("wait to receive:  %s\n",buf);
 30     return 0;
 31 }

运行结果


分析：子进程睡眠了5秒后，read调用阻塞，父进程暂时没有读出数据，5秒后子进程向管道中写入数据，父进程才读到数据

（2）O_NONBLOCK enable：read调用返回-1，errno值为EAGAIN

#include<stdio.h>
 #include<unistd.h>
 #include<stdlib.h>
 #include<fcntl.h>
 #include<string.h>
 int main()
 {
     int fd[2];
     if (pipe(fd) == -1){
         perror("pipe error");

	}
     pid_t pid;
     if (pid == -1){
         perror("fork error");
	}
     if (pid == 0){
         close(fd[0]);//close to read
         sleep(5);
         char* str = "luying";
         int len = strlen(str);
        write(fd[1], str, len);
	}
     close(fd[1]);//close to write
     char buf[20] = { 0 };
     int ret = fcntl(fd[0], F_GETFL);//F_GETFL读取文件状态标志
     //int fcntl(int fd, int cmd, ... /* arg */ );
     fcntl(fd[0], F_SETFL, ret | O_NONBLOCK);//设置为阻塞模式
     int net = read(fd[0], buf, 20);
     if (net == -1){
         perror("read error");
	 }
     printf(" receive:  %s\n", buf);
     return 0;
 }

运行结果：


分析：

2.当管道满的时候

（1）O_NONBLOCK disable：write调用阻塞，直到有进程读走数据

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <fcntl.h> 
int main(void)
{
    int fds[2];
    if(pipe(fds) == -1){
        perror("pipe error");
        exit(EXIT_FAILURE);
    }
    int ret;
    int count = 0;
    while(1){
        ret = write(fds[1],"luying",6);//fds[1]默认是阻塞模式
        if(ret == -1){
            perror("write error");
            break;
        }
        count++;
    }
    return 0;
}

运行结果

fd打开时默认是阻塞模式，当pipe缓冲区满时，write操作确实阻塞了，等待其他进程将数据从管道中取走

（2）O_NONBLOCK enable：调用返回-1，errno值为EAGAIN

接下来我们来验证几种有趣的情况~

（1）写端一直在写，读端不关闭自己的读端，但是他也不读，会出现什么问题呢？

我们用代码实现一下：

#include<stdio.h>
 #include<unistd.h>
 #include<string.h>
int main()
{
	int fd[2];
	int ret = pipe(fd);
	if (ret < 0){
		perror("error pipe");
		return 1;
	}
	pid_t id = fork();
	if (id == 0){//child  ->w
		close(fd[0]);
		const char * msg = "hello father,I am child\n";
		int count = 0;
		while (1){
			write(fd[1], msg, strlen(msg));
			printf("%d\n", count++);
		}
	}
	else{//father  ->r
		close(fd[1]);
		while (1){}
	}
}

结果显示：


分析，我们发现，写端写满之后，暂时不在写数据，那是否是在等待读端读走之后再继续写呢？为了验证我们的想法，我们修改下代码

#include<stdio.h>
#include<unistd.h>
#include<string.h>
int main()
{
	int fd[2];
	int ret = pipe(fd);
	if (ret < 0){
		perror("error pipe");
		return 1;
	}
	pid_t id = fork();
	if (id == 0){//child  ->w
		close(fd[0]);
		const char * msg = "hello father,I am child\n";
		int count = 0;
		while (1){
			write(fd[1], msg, strlen(msg));
			printf("%d\n", count++);
		}
	}
	else{//father  ->r
		close(fd[1]);
		while (1){
             sleep(5);
             ssize_t s = read(fd[0], buf, sizeof(buf)-1);
             if (s>0){
                 buf[s] = '\0';
                 printf("father say:%s\n", buf);
			}
	}
}
运行结果如下：


分析：我们发现，验证了我们的猜测，子进程写满之后，隔了5秒父进程读走了数据之后，子进程开始继续写入文件

（2）如果今天写端间歇性的写，读端一直在读，那么会发生什么呢：

代码修改为：

#include<stdio.h>
#include<unistd.h>
#include<string.h>
int main()
{
	int fd[2];
	int ret = pipe(fd);
	if (ret < 0){
		perror("error pipe");
		return 1;
	}
	pid_t id = fork();
	if (id == 0){//child  ->w
		close(fd[0]);
		const char * msg = "hello father,I am child\n";
		while (1){
			write(fd[1], msg, strlen(msg));
			sleep(10);
		}
	}
	else{//father  ->r
		close(fd[1]);
		int count = 0;
		while (1){
             ssize_t s = read(fd[0], buf, sizeof(buf)-1);
             if (s>0){
                 buf[s] = '\0';
                 printf("father say:%s\n", buf);
			}
			 printf("father read %d\n", count++);
	}
}
运行结果：


分析，我们发现写端每隔秒写一次，与此同时，读端也在等待写端写入，从而才读入数据

管道如果没数据，读端会一直等待，直到有数据写入，就立即读出

（3）那么如果今天写端写入固定数据之后不仅不写了，而且把写端关闭了，会出现什么情况呢?

#include<stdio.h>
#include<unistd.h>
#include<string.h>
int main()
{
	int fd[2];
	int ret = pipe(fd);
	if (ret < 0){
		perror("error pipe");
		return 1;
	}
	pid_t id = fork();
	int count = 0;
	if (id == 0){//child  ->w
		close(fd[0]);
		const char * msg = "hello father,I am child\n";
		while (1){
			write(fd[1], msg, strlen(msg));
			printf("%d\n", count++);
			if (count > 10){
				close(fd[1]);
				break;
			}
			sleep(1);
		}
	}
	else{//father  ->r
		close(fd[1]);
		int count = 0;
		while (1){
             ssize_t s = read(fd[0], buf, sizeof(buf)-1);
             if (s>0){
                 buf[s] = '\0';
                 printf("father say:%s\n", buf);
			 }
			 else if (s == 0){
				 printf("pipe close\n");
				 break;
			 }
	}
}

运行结果：



分析：我们可以看到，当写端不再写的时候，读端读到管道的末尾之后退出

（4）写端一致在写，读端不但不读，而且还关闭了读端，那么写端会发生什么情况呢？

修改代码如下：

#include<stdio.h>
#include<unistd.h>
#include<string.h>
int main()
{
	int fd[2];
	int ret = pipe(fd);
	if (ret < 0){
		perror("error pipe");
		return 1;
	}
	pid_t id = fork();
	int count = 0;
	if (id == 0){//child  ->w
		close(fd[0]);
		const char * msg = "hello father,I am child\n";
		while (1){
			write(fd[1], msg, strlen(msg));
			printf("%d\n", count++);
			sleep(1);
		}
	}
	else{//father  ->r
		close(fd[1]);
		int count = 0;
		while (1){
             ssize_t s = read(fd[0], buf, sizeof(buf)-1);
             if (s>0){
                 buf[s] = '\0';
                 printf("father say:%s\n", buf);
				 sleep(3);
				 break;
			 }
		}
		close(fd[0]);
		int status = 0;
		wait(&status);
		printf("sig:%d\n", status & 0x7F);
	}
}

运行结果如下：


分析：如果所有管道 读端对应的文件描述符被关闭，则write操作会产生信号SIGPIPE,进而可能导致write进程退出

【注意】

1.如果所有管道写端对应的文件描述符被关闭，则read返回0；

2.如果所有管道 读端对应的文件描述符被关闭，则write操作会产生信号SIGPIPE,进而可能导致write进程退出

3.当要写入的数据量不大于PIPE_BUF时，linux将保证写入的原子性

4.当要写入的数据量大于PIPE_BUF时，linux将不再保证写入的原子性

那么PIPE_BUF是多大呢？


认识了匿名管道，我们来看看命名管道

命名管道

如果我们想在不相关的进程之间交换数据，可以使用FIFO文件来做这项工作

命名管道与匿名管道的区别

（1）匿名管道由pipe函数创建并打开，而命名管道由mkfifo函数创建，打开用open

（2）匿名管道只能在具有血缘关系的进程间通信

（3）FIFO（命名管道）与pipe（匿名管道）之间只是创建于打开的方式不同，工作完成之后，他们具有相同的意义

创建命名管道

（1）命令行上创建

$ mkfifo filename

（2）程序中创建，相关函数

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

创建命名管道：

int main(int argc, char *argv[])
{
mkfifo("p2", 0644);
return 0;
}

命名管道的打开规则

1.如果当前打开操作是为读而打开FIFO时

（1）O_NONBLOCK disable：阻塞直到有相关进程为写而打开该FIFO

  (2)   O_NONBLOCK enable：立刻返回成功

2.如果当前打开操作是为写而打开FIFO时

（1）O_NONBLOCK disable：阻塞直到有相关进程为读而打开该FIFO

（2） (2)   O_NONBLOCK enable：立刻返回失败，错误码为ENXIO

应用实例----》用命名管道实现server&client通信

Makefile

.PHONY:all
all : server client
server : server.c
    gcc - o $@ $ ^
client:client.c
    gcc - o $@ $ 
.PHONY:clean
 clean :
    rm - f server client

server.c

#include<stdio.h>
#include<unistd.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<string.h>
#include<fcntl.h>
int main()
{
     if (mkfifo("./fifo", 0644)<0){
         perror("error mkfifo\n");
         return 1;
	}
     int fd = open("./fifo", O_RDONLY);
     if (fd < 0){
         perror("error open");
         return 2;
	}
     char buf[100];
     while (1){
         ssize_t s = read(fd, buf, sizeof(buf)-1);
         if (s > 0){
             buf[s] = '\0';
             printf("client---->server: %s\n", buf);
		}
		else if (s == 0){
             printf("client quit\n");
             break;
		}
	}
     close(fd);
     return 0;
}

运行结果


至此，今天，我们就把管道讨论完了，认识比较浅，代码能力也比较差，希望大家多多指教！

Linux进程间通信 | 管道
ZY-JIMMY
03-05 1110
文章目录进程间通信简介(IPC)管道机制的基本概念什么是管道管道通信的特点匿名管道管道的创建与关闭管道的读写命名管道命名管道的概念命名管道与管道的区别命名管道的创建命名管道的读写 进程间通信简介(IPC) 进程间通信就是在不同进程之间传播或交换信息，那么不同进程之间存在着什么双方都可以访问的介质呢？进程的用户空间是互相独立的，一般而言是不能互相访问的，唯一的例外是共享内存区。另外，系统空间是“公共...
Linux 进程间通信（管道）
2201_75663820的博客
09-22 2289
进程间通信、匿名管道、命名管道 ...
Linux环境进程间通信系列（一）：管道及有名管道
lne818的专栏
07-31 1240
在本系列序中作者概述了 linux 进程间通信的几种主要手段。其中管道和有名管道是最早的进程间通信机制之一，管道可用于具有亲缘关系进程间的通信，有名管道克服了管道没有名字的限制，因此，除具有管道所具有的功能外，它还允许无亲缘关系进程间的通信。 认清管道和有名管道的读写规则是在程序中应用它们的关键，本文在详细讨论了管道和有名管道的通信机制的基础上，用实例对其读写规则进行了程序验证，这样做有利于增强读
linux 进程间通信管道
weixin_45209331的博客
09-18 217
apue管道通信
linux进程间通信-管道
ndzjx的专栏
04-03 330
原创：https://blog.youkuaiyun.com/ndzjx/article/details/89001324 当一个进程连接数据流到另一个进程是，我们使用术语管道(pipe)，通常把一个进程的输出通过管道连接到另一个进程的输入。 最简单的在两个程序间传递数据的方法是使用popen/pclose函数，pclose将等待该进程的结束。如果调用pclose之前执行了wait，即进程表中...
Linux——进程间通信（管道）
qq_44824574的博客
03-04 1248
前提 同时处理多个业务模块，多个业务模块可能需要相互传递数据，也可能需要同步控制。 两个实体需要交互通信，必须有能够共享的资源。 磁盘上的文件：——>IO处理，速度慢，且存在不同步的问题。 进程通信的应用场景 数据传输：一个进程需要将它的数据发送给另一个进程，发送的数据量在一个字节到几兆字节之间。 共享数据：多个进程想要操作共享数据，一个进程对共享数据的修改，别的进程应该立刻看到。 通知事件：一个进程需要向另一个或一组进程发送消息，通知它（它们）发生了某种事件（如进程终止时要通知父进程）。 资源共享
浅谈Linux进程间通信方式及优缺点
01-11
无名管道是一种半双工的通信方式,数据只能单向流动,而且只能在具有亲缘关系的进程间使用.进程的亲缘关系一般指的是父子关系。无明管道一般用于两个不同进程之间的通信。当一个进程创建了一个管道,并调用fork创建自己...
Linux 进程间通信之管道
敲代码嘞~的博客
08-12 1169
管道文件：管道文件是一种特殊的文件，它存在于内存中，而不是磁盘上。它允许一个进程的输出直接作为另一个进程的输入，从而实现进程间的数据交换和协同工作。
【Linux进程间通信】有名管道详解：从创建到应用的全面解析及实战案例
最新发布
04-12
阅读建议：有名管道是Linux进程间通信的基础知识点之一，建议读者结合实际案例进行练习，特别是编写简单的有名管道通信程序，以便更好地理解和掌握相关概念和技术细节。同时，可以参考文中提供的代码示例进行实践...
Linux进程间通信（管道）
pythoncjave的博客
02-15 1109
来讲一下这个代码的大致方向，第一部肯定是创建管道，然后就是创建子进程，这里我们是让父进程写子进程读，所以关闭父子进程不需要的fd，写入的一方，fd没有关闭，如果有数据，就读，没有数据就等，写入的一方，fd关闭, 读取的一方，read会返回0，表示读到了文件的结尾，最后关闭父子进程fd，回收子进程。总结管道的特点，理解以前的管道 | ，管道是一个文件–读取–具有访问控制，显示器也是一个文件，父子同时往显示器写入的时候，有没有说一个会等另一个的情况呢，缺乏访问控制。管道是Unix中最古老的进程间通信的形式。
Linux之进程间通信——管道
一只小卷毛的博客
06-09 2624
管道是Linux中最古老的进程间通信的方式,本文介绍了进程间通信的相关概念，主要介绍了匿名管道和命名管道。
Linux下进程间通信方式——pipe（管道）
weixin_43087913的博客
04-28 489
Linux下进程间通信方式——pipe（管道） 参考自：https://www.cnblogs.com/wuyepeng/p/9747557.html 每个进程有 不同的用户地址空间，任何一个进程的全局变量在另一个进程中是不可见的 所以进程之间要交换数据必须通过内核，在内核中开辟一块缓冲区，进程A把数据从用户空间拷贝到内核缓冲区，进程B在从内核缓冲区把数据读走，内核提供的这种机制称为进程间通信。 ...
【Linux】进程间通信——管道通信
2301_79969994的博客
02-15 1717
管道通信是一种进程间通信方式，允许相关进程之间通过管道进行数据传输。管道本质上是一个的数据流，写入数据的一端称为写端，读取数据的一端称为读端。
Linux进程间通信方式——管道详解
xinianbuxiu的博客
10-26 454
管道可分为无名管道（Pipe）及有名管道（FIFO）：管道可用于具有亲缘关系进程间的通信，有名管道克服了管道没有名字的限制，因此，除具有管道所具有的功能外，它还允许无亲缘关系进程间的通信。 管道具有以下特点： (1)管道是半双工的，数据只能向一个方向流动；需要双方通信时，需要建立起两个管道。 (2)只能用于父子进程或者兄弟进程之间（具有亲缘关系的进程）。 (3)单独构成一个独立的文件系统。
Linux进程间通信---有名管道 代码实现
不忘初心的专栏
08-30 2206
一、管道通信的注意事项 （1）执行mkfifo file命令来创建一个管道文件。[admin@localhost code]$ mkfifo pipe [admin@localhost code]$ ls -l total 0 '''p'rw-rw-r-- 1 admin admin 0 8月 30 19:52 pipe //p就代表是管道文件 （2）如果只把管道的写打开，管道是不通的，是写不
linux——进程间通信(管道)
weixin_44690490的博客
04-06 207
概念 进程间通信是指子进程与父进程间的通信，一般用作父进程对子进程的控制或者子进程将其动向告诉父进程，由于进程是一个程序执行的实例，进程之间本身是无法进行通信的，故而运用一种管道将二者联系起来。当然管道并不只限于在父子进程之间通信，如果在子进程中在创建一个进程，我把它称为孙进程，那么子进程的父进程也就是爷进程，他与孙进程之间同样可以用管道进行通信。 创建一个管道 int pipe(int fd[2...
memset()函数及其作用
热门推荐
ypb——奋斗之路
05-11 5万+
1. memset()函数原型是extern void *memset(void *buffer, int c, int count)        buffer：为指针或是数组,               c：是赋给buffer的值,        count：是buffer的长度.        这个函数在socket中多用于清空数组.如:原型是memset(buffer, 0,
TCP/IP
baidu_17640849的专栏
04-28 579
TCP 与 UDP的区别 TCP面向连接（如打电话要先拨号建立连接）;UDP是无连接的，即发送数据之前不需要建立连接 TCP提供可靠的服务。也就是说，通过TCP连接传送的数据，无差错，不丢失，不重复，且按序到达;UDP尽最大努力交付，即不保 证可靠交付 TCP面向字节流，实际上是TCP把数据看成一连串无结构的字节流;UDP是面向报文的 UDP没有拥塞控制，因此网络出现拥塞
c语言怎么确定文件中指定行,如何用C语言，读文件中某行某列的数据。
weixin_34621186的博客
05-19 2347
匿名用户1级2011-09-07 回答#include #include #include int fileToFile(char *nameSrc, char *nameDes);char * getLineBuf(int line, int col, int len, char *filename);/**********************************************...
Linux进程间通信：管道详解
"创建一个管道-Linux 进程间通信" 在Linux操作系统中，进程间通信（IPC，Inter-Process Communication）是不同进程之间交换信息的重要方式。Unix系统提供了多种IPC机制，其中包括管道、信号量、共享内存区、消息...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值