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;
}

一方写，一方读：

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

相关推荐
watermelonoops11 分钟前
Deepin和Windows传文件（Xftp，WinSCP）
linux·ssh·deepin·winscp·xftp
疯狂飙车的蜗牛1 小时前
从零玩转CanMV-K230（4）-小核Linux驱动开发参考
linux·运维·驱动开发
远游客07133 小时前
centos stream 8下载安装遇到的坑
linux·服务器·centos
马甲是掉不了一点的<.<3 小时前
本地电脑使用命令行上传文件至远程服务器
linux·scp·cmd·远程文件上传
jingyu飞鸟3 小时前
centos-stream9系统安装docker
linux·docker·centos
超爱吃士力架4 小时前
邀请逻辑
java·linux·后端
cominglately6 小时前
centos单机部署seata
linux·运维·centos
魏 无羡6 小时前
linux CentOS系统上卸载docker
linux·kubernetes·centos
CircleMouse6 小时前
Centos7, 使用yum工具，出现 Could not resolve host: mirrorlist.centos.org
linux·运维·服务器·centos
木子Linux7 小时前
【Linux打怪升级记 | 问题01】安装Linux系统忘记设置时区怎么办？3个方法教你回到东八区
linux·运维·服务器·centos·云计算
热门推荐
01〔AI 绘画〕Stable Diffusion 之 解决绘制多人或面部很小的人物时面部崩坏问题 篇02ARM学习（31）编译器对overlay方式的支持03玄机平台应急响应—webshell查杀04DisplayPort AltMode On Type-c协议_Ver2.0(学习笔记)05校验 GPT-4 真实性的三个经典问题：快速区分 GPT-3.5 与 GPT-4，并提供免费测试网站06Docker 夺命连环 15 问076个主流的工业3D管道设计软件08基于大语言模型（LLM）的合成数据生成、策展和评估的综述09(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明10树莓派 5 AI 套件（Hailo-8L）使用教程