Linux下的系统编程——进程间的通信（九）

我想学LINUX2023-09-10 20:46

前言：

前面我们已经对进程已经有了一个简单的了解与认识，那么进程间的通信是什么样的呢，什么是父子进程，什么是兄弟进程，没有血缘关系间的进程是如何实现进程通信的，下面让我们一起学习一下什么是进程间的通信吧。

目录

一、进程间通信常用方式

IPC方式：

二、管道

1.概念：

*2.pipe函数：

*3.管道的读写行为：

[4.父子间进程 ：](#4.父子间进程 ：)

5.兄弟间进程通信：

6.多个读写端操作管道

7.管道缓冲区大小：

.8.管道的优劣

三、FIFO:

1.命名管道fifo的创建和原理：

2.非血缘关系进程间通信avi：

一、进程间通信常用方式

IPC方式：

Linux环境下，进程地址空间相互独立，每个进程各自有不同的用户地址空间。任何一个进程的全局变量在另一个进程中都看不到，所以进程和进程之间不能相互访问，要交换数据必须通过内核，在内核中开辟一块缓冲区 ，进程1把数据从用户空间拷到内核缓冲区，进程2再从内核缓冲区把数据读走，内核提供的这种机制称为进程间通信 （IPC,InterProcess Communication)。

在进程间完成数据传递需要借助操作系统提供特殊的方法，如:文件、管道、信号、共享内存、消息队列、套接字、命名管道等。随着计算机的蓬勃发展，一些方法由于自身设计缺陷被淘汰或者弃用。现今常用的进程间通信方式有:

1.管道（使用最简单)

2.FIFO(无血缘关系，单次读取)

3.共享映射区(无血缘关系，反复读取)

4.信号(开销最小)

5.本地套接字(最稳定)

二、管道

1.概念：

管道 是一种最基本的IPC机制，作用于有血缘关系的进程之间，完成数据传递。调用pipe系统函数即可创建一个管道。有如下特质:

（1）.其本质是一个伪文件(实为内核缓冲区)

（2）.由两个文件描述符引用 ，一个表示读端 ，一个表示写端，只能一次读取。

（3）.规定数据从管道的写端流入管道 ，从读端流出，单向流动。

管道的原理: 管道实为内核使用环形队列机制 ，借助内核缓冲区(4k)实现。

管道的局 限性:

1）数据不能进程自己写，自己读。·

2）管道中数据不可反复读取。一旦读走，管道中不再存在。

3）采用半双工通信 方式，数据只能在单方向上流动。

4）只能在有公共祖先的进程间使用管道

常用的通信方式： 单工通信、半双工通信、全双工通信

创建管道文件：

（不占用磁盘空间）

*2.pipe函数：

pipe函数：用于有血缘关系的进程间通信

函数功能：创建，并打开管道。

int pipe(int fd[2]);

参数：

fd[0]: 读端。

fd[1]: 写端。

返回值：

成功： 0

失败： -1 errno

管道通信：

cpp 复制代码 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <pthread.h>

void sys_err(const char *str)
{
	perror(str);
	exit(1);
}


int main(int argc, char *argv[])
{
	int ret,re;
	int fd[2];
	pid_t pid;
	char *str = "hello pipe\n";
	char buf[1024];

	ret = pipe(fd);     //父进程先创建一个管道,持有管道的读端和写端
	if(ret == -1)
		sys_err("pipe error");
	
	pid = fork();        //子进程同样持有管道的读和写端

	if(pid > 0){            //父进程
		close(fd[0]);       //关闭读段
		write(fd[1],str,strlen(str));//写入数据
        sleep(1);
		close(fd[1]);            //关闭写段
	}else if(pid == 0){        //子进程
		close(fd[1]);          //关闭写段
		re = read(fd[0],buf,sizeof(buf)); //读取数据
		write(STDOUT_FILENO,buf,re);      //写到屏幕上
		close(fd[0]);        //关闭读段
	}

	return 0;

}

*3.管道的读写行为：

读管道：

  1. 管道有数据，read返回实际读到的字节数。

  2. 管道无数据：

1）无写端，read返回0 （类似读到文件尾）

2）有写端，read阻塞等待。

写管道：

  1. 无读端， 异常终止。 （SIGPIPE导致的）

  2. 有读端：

1） 管道已满， 阻塞等待（少见）

2） 管道未满， 返回写出的字节个数。

1）读管道，管道无数据（无写端）

cpp 复制代码 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <pthread.h>

void sys_err(const char *str)
{
	perror(str);
	exit(1);
}


int main(int argc, char *argv[])
{
	int ret,re;
	int fd[2];
	pid_t pid;
	char *str = "hello pipe\n";
	char buf[1024];

	ret = pipe(fd);    //父进程先创建一个管道,持有管道的读端和写端
	if(ret == -1)
		sys_err("pipe error");
	
	pid = fork();        //子进程同样持有管道的读和写端

	if(pid > 0){            //父进程
		close(fd[0]);       //关闭读段
	//	write(fd[1],str,strlen(str));//写入数据
		close(fd[1]);            //关闭写段
	}else if(pid == 0){        //子进程
		close(fd[1]);          //关闭写段
		re = read(fd[0],buf,sizeof(buf)); //读取数据
		
		printf("child read ret =%d\n",ret);
		
		write(STDOUT_FILENO,buf,re);      //写到屏幕上
		close(fd[0]);        //关闭读段
	}

	return 0;

}

read返回0

*4.父子间进程通信 ：

使用管道实现父子进程间通信 ，完成:ls | wc -l。假定父进程实现ls，子进程实现wc

ls | wc -l命令：

实现流程：

（1）父进程创建管道 pipe()

（2）父进程创建子进程 fork()

（3）设置父进程执行ls命令，子进程执行wc命令 execlp()

（4）设置父子进程通过管道的单项流动(设置指向标准输出的指向管道 ) dup2()

cpp 复制代码 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <pthread.h>

void sys_err(const char *str)
{
	perror(str);
	exit(1);
}

int main(int argc,char *argv[])
{
	/***************
		dup2();
		fork();
		pipe();
		execlp();
	****************/
	int fd[2]; 
	int ret;
	pid_t pid;

    //父进程创建管道
	ret = pipe(fd);     //父进程先创建一个管道,持有管道的读端和写端
	if(ret == -1){
		sys_err("pipe error");
	}

    //父进程创建子进程 
	pid = fork();        //子进程同样持有管道的读和写端

	if(pid == -1){
		sys_err("fork error");
	}else if(pid > 0){                     //父进程 读，关闭写端
		close(fd[1]);                      //关闭写，设置单项流动
		dup2(fd[0],STDIN_FILENO);          //设置读管道信息，重定向stdin 到管道读端
		execlp("wc","wc","-l",NULL);       //设置父进程wc命令
		sys_err("execlp wc error");
	}else if(pid == 0){
		
        close(fd[0]);                      //关闭读，设置单项流动
		dup2(fd[1],STDOUT_FILENO);         //设置写操作指向管道,重定向stdout 到管道写端
		execlp("ls","ls",NULL);            //设置子进程执行ls命令 
		sys_err("execlp ls error");
	}

	return 0;
}

5.兄弟间进程通信：

使用管道实现兄弟进程间通信 ，完成:ls | wc -l。假定父进程实现ls，子进程实现wc

实现流程：

（1）父进程创建管道 pipe()

（2）父进程创建俩个（兄弟）子进程 fork()

（3）设置兄进程执行ls命令，第进程执行wc命令 execlp()

（4）设置兄弟进程通过管道的单项流动(设置指向标准输出的指向管道 ) dup2()

（5）回收父进程残余文件 wait()

刚创建出的兄弟进程：

设置兄弟进程通过管道的单项流动后

cpp 复制代码 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <pthread.h>
#include <sys/wait.h>

void sys_err(const char *str)
{
	perror(str);
	exit(1);
}

int main(int argc,char *argv[])
{
	/***************
		dup2();
		fork();
		pipe();
		execlp();
        wait();
	****************/
	int fd[2]; 
	int ret;
	int i;
	pid_t pid;

    //父进程创建管道
	ret = pipe(fd);
	if(ret == -1){
		sys_err("pipe error");
	}

	for(i = 0;i < 2;i++){              //表达式2 出口，仅限父进程使用
		pid = fork();
		if(pid == -1){
			sys_err("fork error");
		}
		if(pid == 0)                   //子进程出口
			break;
	}



	if(i == 2){                        //父进程 不参与管道使用
        //不需要父进程所以需要关闭他管道的读写端
		close(fd[0]);          
		close(fd[1]);
        //回收子进程
		wait(NULL);
		wait(NULL);
	}else if(i == 0){                  //兄进程
		close(fd[0]);
		dup2(fd[1],STDOUT_FILENO);     //重定向stdout
		execlp("ls","ls",NULL);        //兄进程执行ls命令
		sys_err("ececlp ls error");
	}else if(i == 1){		           //弟进程
		close(fd[1]);
		dup2(fd[0],STDIN_FILENO);      //重定向stdin
		execlp("wc","wc","-l",NULL);   //弟进程执行wc命令
		sys_err("ececlp wc error");
	}

	return 0;
}

6.多个读写端操作管道

实现一个pipe有一个写端，多个读端

cpp 复制代码 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <pthread.h>
#include <sys/wait.h>

void sys_err(const char *str)
{
	perror(str);
	exit(1);
}

int main(int argc,char *argv[])
{
	/***************
		dup2();
		fork();
		pipe();
		execlp();
	****************/
	int fd[2],i,n; 
	int ret;
	char buf[1024];
	pid_t pid;

    //父进程创建管道
	ret = pipe(fd);
	if(ret == -1){
		sys_err("pipe error");
		exit(1);
	}

	for(i = 0;i < 2;i++){
		pid = fork();
		if(pid == -1){
			sys_err("fork error");
			exit(1);
		}
		if(pid == 0)
			break;
	}


	if(i == 2){            //父进程
		close(fd[1]);       //父进程关闭写端，留读端读取数据
		sleep(1);
		n = read(fd[0],buf,1024);    //从管道中读取数据
		write(STDOUT_FILENO,buf,n); 
 
		for(i == 0;i < 2;i++)        //两个儿子wait两次
			wait(NULL);

	}else if(i == 0){        //兄进程
		close(fd[0]);
		write(fd[1],"1.hello\n",strlen("1.hello\n"));
	}else if(i == 1){		 //弟进程
		close(fd[0]);
		write(fd[1],"2.world\n",strlen("2.world\n"));
	}

	return 0;
}

7.管道缓冲区大小：

可以使用ulimIt -a 命令来查看当前系统中创建管道文件所对应的内核缓冲区大小。通常为:

pipe size ......(512 bytes,-p) 8

也可以使用fpathconf 函数，借助参数―选项来查看。使用该宏应引入头文件<unistd.h>

long fpathconf(int fd, int name);成功:返回管道的大小―失败:-1，设置errno

.8.管道的优劣

优点:简单，相比信号，套接字实现进程间通信，简单很多。

缺点:

1.只能单向通信，双向通信需建立两个管道。

2.只能用父子、兄弟进程(有共同祖先)间通信。该问题后来使用fifo有名管道解决）

三、FIFO:

fifo管道：可以用于无血缘关系的进程间通信。

命名管道： mkfifo

无血缘关系进程间通信：

读端，open fifo O_RDONLY

写端，open fifo O_WRONLY

1.命名管道fifo的创建和原理：

使用命令：myfifo myfifo

使用myfifo创建

cpp 复制代码 
#include<stdio.h>
#include<sys/stat.h>
#include<errno.h>
#include<pthread.h>
#include<stdlib.h>


void sys_err(const char *str){
	perror(str);
	exit(1);
}

int main(int argc,char *str)
{
	int ret = mkfifo("mytestfifo",0664);
	if(ret == -1)
		sys_err("mkfifo error");

	return 0;
	
}

2.非血缘关系进程间通信avi：

向管道写数据 ：fifo_w.c

cpp 复制代码 
#include <stdio.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>
#include <stdlib.h>
#include <string.h>

void sys_err(char *str)
{
    perror(str);
    exit(-1);
}

int main(int argc, char *argv[])
{
    int fd, i;
    char buf[4096];

    if (argc < 2) {
        printf("Enter like this: ./a.out fifoname\n");
        return -1;
    }
    fd = open(argv[1], O_WRONLY);       //打开管道文件
    if (fd < 0) 
        sys_err("open");

    i = 0;
    while (1) {
        sprintf(buf, "hello itcast %d\n", i++);

        write(fd, buf, strlen(buf));    // 向管道写数据
        sleep(1);
    }
    close(fd);

    return 0;
}

向管道读数据 ：fifo_r.c

cpp 复制代码 
#include <stdio.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>
#include <stdlib.h>
#include <string.h>

void sys_err(char *str)
{
    perror(str);
    exit(1);
}

int main(int argc, char *argv[])
{
    int fd, len;
    char buf[4096];

    if (argc < 2) {
        printf("./a.out fifoname\n");
        return -1;
    }


    fd = open(argv[1], O_RDONLY);   // 打开管道文件
    if (fd < 0) 
        sys_err("open");
    while (1) {
        len = read(fd, buf, sizeof(buf));   // 从管道的读端获取数据
        write(STDOUT_FILENO, buf, len);
        sleep(3);           //多個读端时应增加睡眠秒数,放大效果.
    }
    close(fd);

    return 0;
}

一方写，一方读：

一个写，多个读：管道特性，不能反复读取

相关推荐
真果粒wrdms24 分钟前
【SQLite3】常用API
linux·服务器·c语言·jvm·数据库·oracle·sqlite
Tassel_YUE1 小时前
iptables配置实现NAT（随手记）
linux·运维·服务器·网络·iptables
IT利刃出鞘2 小时前
SecureCRT--使用sftp上传和下载文件
linux·运维·服务器
踩着阴暗的自己向上爬5 小时前
Day05-04-持续集成总结
linux·运维·ci/cd
几度春风里5 小时前
嵌入式Linux系统编程 — 7.2 进程的环境变量
嵌入式·linux系统编程·进程的环境变量
qyhua6 小时前
Linux内网端口转公网端口映射
linux·运维·服务器
j.king7 小时前
开源GTKSystem.Windows.Forms框架让C# winform支持跨平台运行
linux·c#·gtk
stackY、8 小时前
【Linux】：程序地址空间
linux·算法
R语言爱好者9 小时前
如何查看程序是否在运行-Linux
linux
逆风就重开10 小时前
数据埋点从入门到了解
大数据·linux·前端·数据库·数据仓库
热门推荐
012024年江苏省研究生数学建模科研创新实践大赛C题气象数据高精度融合技术研究论文和代码分析02Coze扣子平台完整体验和实践（附国内和国际版对比）03组基轨迹建模 GBTM的介绍与实现（Stata 或 R）042024亚太赛（中文赛）数学建模竞赛选题建议+初步分析05yolov8实战第五天——yolov8+ffmpg实时视频流检测并进行实时推流——（推流，保姆教学）06【经验分享】Ubuntu22.04安装微信(linux官方版)07通用大模型VS垂直大模型，你更青睐哪一方？082025张宇考研数学，百度网盘视频课+36讲PDF讲义+真题09【立创EDA-PCB设计基础】6.布线铺铜实战及细节详解102024 年第十四届 APMCM 亚太地区大学生数学建模竞赛B题超详细解题思路+数据预处理问题一代码分享