操作系统实验5-进程通信：（二）管道通信

mrqzgmzlb

已于 2023-04-16 14:46:17 修改

阅读量3.4k

点赞数 6

文章标签： unix windows linux

于 2023-04-16 11:28:43 首次发布

本文链接：https://blog.csdn.net/mrqzgmzlb/article/details/130070772

版权

【实验相关资料】

一、什么是管道

UNIX系统在OS的发展上，最重要的贡献之一便是该系统首创了管道（pipe）。这也是UNIX系统的一大特色。

所谓管道，是指能够连接一个写进程和一个读进程的、并允许它们以生产者—消费者方式进行通信的一个共享文件，又称为pipe文件。由写进程从管道的写入端（句柄1）将数据写入管道，而读进程则从管道的读出端（句柄0）读出数据

二、管道的类型：

1．有名管道

   一个可以在文件系统中长期存在的、具有路径名的文件。用系统调用mknod( )建立。它克服无名管道使用上的局限性，可让更多的进程也能利用管道进行通信。因而其它进程可以知道它的存在，并能利用路径名来访问该文件。对有名管道的访问方式与访问其他文件一样，需先用open( )打开。

2．无名管道

一个临时文件。利用pipe( )建立起来的无名文件（无路径名）。只用该系统调用所返回的文件描述符来标识该文件，故只有调用pipe( )的进程及其子孙进程才能识别此文件描述符，才能利用该文件（管道）进行通信。当这些进程不再使用此管道时，核心收回其索引结点。二种管道的读写方式是相同的，本次实验使用无名管道。

3．pipe文件的建立

    分配磁盘和内存索引结点、为读进程分配文件表项、为写进程分配文件表项、分配用户文件描述符

4．读/写进程互斥

    内核为地址设置一个读指针和一个写指针，按先进先出顺序读、写。为使读、写进程互斥地访问pipe文件，需使各进程互斥地访问pipe文件索引结点中的直接地址项。因此，每次进程在访问pipe文件前，都需检查该索引文件是否已被上锁。若是，进程便睡眠等待，否则，将其上锁，进行读/写。操作结束后解锁，并唤醒因该索引结点上锁而睡眠的进程。

三、本次实验所涉及的系统调用

1．pipe( )创建无名管道

建立一无名管道。

系统调用格式

              pipe(filedes)

参数定义

int pipe(filedes);

int  filedes[2];

其中，filedes[1]是写入端，filedes[0]是读出端。

该函数使用头文件如下：

#include <unistd.h>

#inlcude <signal.h>（好像不需要这个）

#include <stdio.h>

【实验目的】

1．了解管道的概念。

2．掌握Linux支持的管道通信方式。

【实验内容】

1. 编写一段程序，实现进程的管道通信。使用pipe()建立一个管道。子进程p1向管道写一句话：

Child process is sending message!

而父进程则从管道中读取来自于子进程的信息，显示在屏幕上。

参考程序：


int pid1；   //存储子进程的PID号；

int main()

{

  int  fd[2]；     //打开文件的文件描述符

  char  OutPipe[100],InPipe[100]； //存储要写入管道的字符串

  pipe(fd)；              //创建无名管道

while((pid1 = fork()) = = -1)；

if(pid1  = = 0)

{

   sprintf(OutPipe，“ Child  process is sending message!”)；

   write(fd[1],OutPipe,50)；

   sleep(1)；

   exit(0)；

}

  else

  {

   wait(0)；

   read(fd[0],InPipe,50)；

   printf(“%s\n”,InPipe)；
   exit(0)；

}

return  0；

}

实验要求：

运行程序并分析结果。
修改程序实现10次读、写管道文件的操作，应如何实现，请编写代码，并运行程序分析结果。

2．编写一段程序，实现进程的管道通信。使用pipe()建立一条管道线。两个子进程p1和p2分别向管道各写一句话：

Child 1 is sending message!

Child 2 is sending message!

而父进程则从管道中分别读出来自于两个子进程的信息，显示在屏幕上。

<参考程序>


# include<unistd.h>

# include<signal.h>

# include<stdio.h>

# include<stdlib.h>

#include<sys/wait.h>

#include<sys/types.h>

int pid1,pid2;   //存储两个子进程的PID号；

main()

{

  int fd[2];    //打开文件的文件描述符

  char OutPipe[100],InPipe[100]; //存储要写入管道的字符串

  pipe(fd);             //创建无名管道

/*  代码请大家自己编写  */

}

3.编写一段程序，实现：在父进程中用pipe()建立一条管道，往管道里写入两句话（字符串），两个子进程分别接收来自父进程写入的两句话并打印输出。

【实验要求】

1．列出调试通过程序的清单，对运行结果截图并进行分析。（每题20分）

2．为每个程序加注释（每题10分）。

3．总结上机调试过程中所遇到的问题和解决方法及感想。（10分）

【实验步骤和结果】

（1）

pipe(fd); //创建无名管道注意位置，必须使输入输出的进程都创建了管道

#include<stdio.h>
#include<stdlib.h>
#include<sys/wait.h>
#include<unistd.h>
#include<sys/types.h>
int pid1;      //存储子进程的PID号；
int main()
{
	int fd[2];   //打开文件的文件描述符
	char OutPipe[100],InPipe[100];    
	pipe(fd);	//创建无名管道    注意位置，必须使输入输出的进程都创建了管道
	while((pid1=fork())==-1);   //先pipe再fork：创建了2个管道，分别在父进程和子进程
	if(pid1==0)
	{
		sprintf(OutPipe,"child process is sending message!\n");//将字符串存储outpipe里
		write(fd[1],OutPipe,50);//将50个字节的数据从outpipe写入到fd[1]端
		sleep(1);//休眠1秒,防止读写冲突
		exit(0);//休眠1秒,防止读写冲突
	}
	else
	{
		wait(0);//等待子进程
		read(fd[0],InPipe,50);//将50个字节的数据从fd[0]中读出到inpipe里
		printf("%s\n",InPipe);//打印inpipe内字符串
		exit(0);
	}
	return 0;
}

不需要signal的头文件也能运行？

使用pipe函数创建一个管道，让子进程向管道中写入一句话：Child process is sending message!”而父进程从管道中读出这句话，停顿一秒后显示在屏幕上。

(2)


#include<stdio.h>
#include<stdlib.h>
#include<sys/wait.h>
#include<unistd.h>
#include<sys/types.h>
int pid1;
int main()
{
	int fd[2];
	char OutPipe[100],InPipe[100];
	pipe(fd);
	while((pid1=fork())==-1);
	if(pid1==0)
	{
		for(int i=1;i<=10;i++)
{
		sprintf(OutPipe,"child process is sending message!\n");
		write(fd[1],OutPipe,50);
		sleep(1);
}
		exit(0);
	}
	else
	{
//		wait(0);
		for(int j=1;j<=10;j++)
{
		read(fd[0],InPipe,50);
		printf("%s\n",InPipe);

}		wait(0);
		exit(0);
	}
	return 0;
}

循环次数越多，停顿时间越长再输出

等全部输入以后，输出的进程才全部输出

//在子进程1写入的过程中，禁止子进程2写入

#include<stdio.h>
#include<stdlib.h>
#include<sys/wait.h>
#include<unistd.h>
#include<sys/types.h>
#include<signal.h>
int pid1,pid2;//存储子进程pid号
int main()
{
	int fd[2];//打开文件的文件描述符
	char OutPipe[100],InPipe[100];
	pipe(fd);

	while((pid1=fork())==-1);
	if(pid1==0)
	{
		lockf(fd[1],1,0);//上锁，为了两个子进程之间的互斥
//在子进程1写入的过程中，禁止子进程2写入
	sprintf(OutPipe,"child1 process is sending message!\n");
		write(fd[1],OutPipe,50);
		sleep(1);//休眠1秒，防止写冲突
		lockf(fd[1],0,0);//解锁，与上锁成对使用
		exit(0);
	}
	else
	{
		while((pid2=fork())==-1);
		if(pid2==0)
		{
		lockf(fd[1],1,0);
		sprintf(OutPipe,"child2 process is sending message!\n");
		write(fd[1],OutPipe,50);
		sleep(1);
		lockf(fd[1],0,0);
		exit(0);
		}
		else
		{
		wait(0);	
		wait(0);
		read(fd[0],InPipe,50);
		printf("%s\n",InPipe);
		read(fd[0],InPipe,50);
		printf("%s\n",InPipe);
		exit(0);
		}
	}
	return 0;
}

顺序：和电脑性能或者争抢cpu有关？先进先出？（见总结）

# include<unistd.h>
# include<signal.h>
# include<stdio.h>
# include<stdlib.h>
#include<sys/wait.h>
#include<sys/types.h>

int pid1,pid2;  //存储两个子进程的PID号；
int main()
{
	int fd[2];   //打开文件的文件描述符
  	char OutPipe[100],InPipe[100]; //存储要写入管道的字符串
  	pipe(fd);//创建无名管道
  	while((pid1=fork())==-1);  //用fork函数创建子进程
	if(pid1==0){       
//	sleep(1);
	read(fd[0],InPipe,50);  //将字符串从管道中读出到inpipe
	printf("i am the first child. %s\n",InPipe);
	exit(0);//安全退出
	}
	else{
	while((pid2=fork())==-1);   
	if(pid2==0){  
//	sleep(1);
	read(fd[0],InPipe,50);  //将字符串从管道中读出到inpipe
	printf("i am the second child.%s\n",InPipe);  //打印inpipe内数据
	exit(0);
	}
	else{                   //父进程
	sprintf(OutPipe,"father is sending a message to Child process 1!");
	write(fd[1],OutPipe,50);
	sprintf(OutPipe,"father is sending a message to Child process 2!");
	write(fd[1],OutPipe,50);
	wait(0);
	wait(0);
	exit(0);
	}
	}
return 0;
}

【实验总结和体会】

int fd[2]

是一个长度为2的数组，用于在UNIX/Linux系统下进行进程间通信。这个数组包含两个整型元素，其中fd[0]代表读取端文件描述符，fd[1]代表写入端文件描述符。在进程间通信中，一个进程可以向管道里写入数据，而另一个进程则可以从同一个管道中读取这些数据。fd[0]和fd[1]是两个半双工的文件描述符，各自只能向一个方向传输数据。

通常，创建管道的方法是使用系统调用pipe()，这会返回两个文件描述符，其中一个指向着管道的读取端，另一个则指向着管道的写入端。设置fd数组的目的是将这两个文件描述符存储在同一个数组中，方便进程使用。在使用管道进行进程间通信时，创建管道后，可以fork()一个新进程，将从父进程继承下来的fd数组传递给子进程，在子进程中直接使用fd数组进行数据传输。

2.sprintf函数作用:

打印到字符串中（要注意字符串的长度要足够容纳打印的内容，否则会出现内存溢出），而printf函数打印输出到屏幕上。sprintf函数在我们完成其他数据类型转换成字符串类型的操作中应用广泛。

3.创建管道的顺序：

先创建管道，后创建子进程

管道通信中，如果先读后写，会造成阻塞。

如图。不能输出，一直闪烁光标。

4.管道读写注意点：

只有在管道的读写端存在时向管道中写入数据才有意义。否则，向管道中写入数据的进程将收到内核传来的SIFPIPE信号(通常Broken pipe错误)。

向管道中写入数据时，linux将不保证写入的原子性，管道缓冲区有一空闲区域，写进程就会试图向管道写入数据。如果读进程不读取管道缓冲区中的数据，那么写操作将会一直阻塞。

父子进程在运行时，它们的先后次序并不能保证，因此，在这里为了保证父进程已经关闭了。读描述符，可在子进程中调用sleep函数。

无名管道作用：

用于父子进程之间的通信。创建管道——读管道——写管道——关闭管道。管道用于不同进程间的通信，通常先创建一个管道，在通过fork函数创建一个子进程，该子进程会继承父进程所创建的管道。

管道内输出顺序：

写入和接收的顺序，应该属于进程争抢cpu等多方面原因导致输出顺序的问题。

当使用管道（ | ）将多个命令连接起来时，输出的顺序取决于每个命令的执行时间和缓冲区的大小。

假设有以下两个命令：command1 | command2

当这两个命令被连接后，command1 的输出将被传输到 command2。如果 command1 的输出量很大，而 command2 处理速度较慢，那么 command1 的输出将会被缓冲起来，直到 command2 可以处理更多数据。

因此，如果 command1 和 command2 的执行时间相近，那么输出的顺序将与命令在管道中的顺序相同。但是，如果 command2 的处理速度较慢，则输出的顺序可能会与命令在管道中的顺序相反。

总之，在使用管道连接多个命令时，输出的顺序可能不是按照输入命令的顺序来的。这取决于每个命令的执行时间和缓冲区的大小，因此可能需要特别注意。

*管道通信的特点：

（1）管道是半双工的，先进先出的（？），它把一个进程的输出和另一个进程的输入连接在一起

（2）一个进程（写进程）在管道的尾部写入数据，另一个进程（读进程）从管道的头部读出数据

5. lockf 文件锁

lockf()函数允许将文件区域用作信号量（监视锁），或用于控制对锁定进程的访问（强制模式记录锁定）。试图访问已锁定资源的其他进程将返回错误或进入休眠状态，直到资源解除锁定为止。当关闭文件时，将释放进程的所有锁定，即使进程仍然有打开的文件。当进程终止时，将释放进程保留的所有锁定。头文件：　#include <unistd.h>

详见实验四

使访问互斥：

读/写进程互斥，为使读、写进程互斥地访问pipe文件，需使各进程互斥地访问pipe文件索引结点中的直接地址项。因此，每次进程在访问pipe文件前，都需检查该索引文件是否已被上锁。若是，进程便睡眠等待，否则，将其上锁，进行读/写。操作结束后解锁，并唤醒因该索引结点上锁而睡眠的进程。根据上述材料，编写代码，先打出一个父进程，两个子进程，一条管道线的框架。再加上互斥锁，sleep函数，wait函数等，防止两个子进程互斥。

6.其他函数：

read( )

系统调用格式

read( fd ,buf ,nbyte )

功能：从fd（一般是fd[0]）所指示的文件中读出nbyte个字节的数据，并将它们送至由指针buf所指示的缓冲区中。如该文件被加锁，等待，直到锁打开为止。

write( )

系统调用格式

write(fd,buf,nbyte)

功能：把nbyte 个字节的数据，从buf所指向的缓冲区写到由fd（一般是fd[1]）所指向的文件中。如文件加锁，暂停写入，直至开锁。