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

前言： 

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

一、进程间通信常用方式

IPC方式：

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

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


1.管道（使用最简单)

2.信号(开销最小)

3.共享映射区(无血缘关系)

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

二、管道

1.概念：

      

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


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

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

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


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

管道的局限性:

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

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

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

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

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

创建管道文件：

（不占用磁盘空间）

*2.pipe函数：

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

    int pipe(int fd[2]);

    参数：    

        fd[0]: 读端。

        fd[1]: 写端。

    返回值：

         成功： 0

         失败： -1 errno

管道通信：

#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）读管道，管道无数据（无写端）

#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()

#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);      //设置读管道信息
		execlp("wc","wc","-l",NULL);        //设置子进程wc命令
		sys_err("execlp wc error");
	}else if(pid == 0){
		
        close(fd[0]);                  //关闭读，设置单项流动
		dup2(fd[1],STDOUT_FILENO);     //设置写操作指向管道
		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()

刚创建出的兄弟进程：

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

#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);
		execlp("ls","ls",NULL);    //兄进程执行ls命令
		sys_err("ececlp ls error");
	}else if(i == 1){		   //弟进程
		close(fd[1]);
		dup2(fd[0],STDIN_FILENO);
		execlp("wc","wc","-l",NULL);//弟进程执行wc命令
		sys_err("ececlp wc error");
	}

	return 0;
}

6.多个读写端操作管道

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

#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创建

#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

#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

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

一方写，一方读：

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

 


http://www.niftyadmin.cn/n/5006903.html

相关文章

20 个最频繁使用的 Python 代码片段

20 个最频繁使用的 Python 代码片段

20 个最频繁使用的 Python 代码片段 1. 简单的 HTTP Web 服务2.单行循环List3.更新字典4.拆分多行字符串5. 跟踪列表中元素的频率6. 不使用 Pandas 读取 CSV 文件7. 将列表压缩成一个字符串8. 获取列表中元素的索引9. *arg 的魔法10. 获取任何数据的类型11.修改打印函数12. 字符…
阅读更多...
docker 部署EMQX

docker 部署EMQX

1、简介 EMQ X (Erlang/Enterprise/Elastic MQTT Broker) 是基于 Erlang/OTP 平台开发的开源物联网 MQTT 消息服务器。 Erlang/OTP是出色的软实时 (Soft-Realtime)、低延时 (Low-Latency)、分布式 (Distributed)的语言平台。 MQTT 是轻量的 (Lightweight)、发布订阅模式 (Pu…
阅读更多...
php如何设置随机数

php如何设置随机数

第一种方法用mt_rand() 第二种方法&#xff08;最快的&#xff09; 第三种取当时时间戳 第四种打乱字符串 5 //开始创建验证码(直接用函数生成&#xff0c;比较方便快捷) php mt_rand生成0~1随机小数的效果比较 第一种方法用mt_rand() function GetRandStr($length){ $s…
阅读更多...
C# wpf 实现截屏框热键截屏功能

C# wpf 实现截屏框热键截屏功能

wpf截屏系列 第一章 使用GDI实现截屏 第二章 使用DockPanel制作截屏框 第三章 实现截屏框热键截屏&#xff08;本章&#xff09; 第四章 实现截屏框实时截屏 第五章 使用ffmpeg命令行实现录屏 文章目录 wpf截屏系列前言一、实现步骤1、响应热键2、截屏显示&#xff08;1&#…
阅读更多...
JWFD开源工作流-矩阵引擎设计-高维向量空间分析法

JWFD开源工作流-矩阵引擎设计-高维向量空间分析法

JWFD开源工作流-矩阵引擎设计-高维向量空间分析法 在把已知的流程节点查找到之后&#xff0c;输出下标&#xff0c;但是我们发现&#xff0c;还有一些节点并未被 探测到&#xff0c;遍历并没有完全的完成&#xff0c;仍然有泄露的节点在其中&#xff0c;这个问题…
阅读更多...
C++内存管理（3）——内存池

C++内存管理（3）——内存池

1. 默认内存管理函数的不足&#xff08;为什么使用内存池&#xff09; 利用默认的内存管理操作符 new/delete 和函数 malloc()/free() 在堆上分配和释放内存会有一些额外的开销。 系统在接收到分配一定大小内存的请求时&#xff0c;首先查找内部维护的内存空闲块表&#xff0…
阅读更多...
C++内存管理（2）new、delete详解

C++内存管理（2）new、delete详解

目录 new operator&#xff08;new操作&#xff09; new类对象时加不加括号的差别 new工作任务 delete工作任务 new和delete 堆区空间操作&#xff08;对比malloc和free&#xff09; new和delete操作基本类型的空间 new和delete操作基本类型的数组 new和delete操作类的…
阅读更多...
小白备战大厂算法笔试(二)——数组、链表、列表

小白备战大厂算法笔试(二)——数组、链表、列表

文章目录 常见数据结构数组初始化访问元素插入元素删除元素遍历数组查找元素扩容数组关于数组 链表初始化插入节点删除节点访问节点查找节点常见类型典型应用 数组VS链表列表初始化访问元素插入与删除元素遍历列表拼接列表排序列表简单实现 常见数据结构 常见的数据结构包括数…
阅读更多...
最新文章

Copyright @ 2022~2023