实验4 进程的管道通信

实验4 进程的管道通信
1. 目的
1）加深对进程概念的理解，明确进程和程序的区别。

2）进一步认识并发执行的实质。

3）分析进程争用资源的现象，学习解决进程互斥的方法。

4）学习解决进程同步的方法。

5）了解Linux系统中进程通信的基本原理。

进程是操作系统中最重要的概念，贯穿始终，也是学习现代操作系统的关键。

通过本次实验，要求理解进程的实质和进程管理的机制。

在Linux系统下实现进程从创建到终止的全过程，从中体会进程的创建过程、父进程和子进程之间的关系、进程状态的变化、进程之间的互斥、同步机制、进程调度的原理和以管道为代表的进程间的通信方式的实现。

2. 内容及要求
这是一个设计型实验，要求自行编制程序。

使用系统调用pipe()建立一条管道，两个子进程分别向管道写一句话：
Child process1 is sending a message!
Child process2 is sending a message!
父进程从管道读出来自两个子进程的信息，显示在屏幕上。

要求：
1）父进程先接收子进程1发来的消息，然后再接收子进程2发来的消息。

2）实现管道的互斥使用,当一个子进程正在对管道进行写操作时，另一子进程必须等待。

使用系统调用lockf(fd[1],1,0)实现对管道的加锁操作，用lockf(fd[1],0,0)解除对
管道的锁定。

3）实现父子进程的同步，当子进程把数据写入管道后，便去睡眠等待；当父进程试图从一空管道中读取数据时，也应等待，直到子进程将数据写入管道后，才将其唤醒。

3．相关的系统调用
1）fork() 用于创建一个子进程。

格式：int fork();
返回值：在子进程中返回0；在父进程中返回所创建的子进程的ID值；当返回-1时，创建失败。

2）wait() 常用来控制父进程与子进程的同步。

在父进程中调用wait()，则父进程被阻塞，进入等待队列，等待子进程结束。

当子进程结束时，父进程从wait()返回继续执行原来的程序。

返回值：大于0时，为子进程的ID值；等于-1时，调用失败。

3）exit() 是进程结束时最常调用的。

格式：void exit( int status); 其中，status为进程结束状态。

4）pipe() 用于创建一个管道
格式：pipe(int fd);
其中fd是一个由两个数组元素fd[0]和fd[1]组成的整型数组，fd[0]是管道的读端口，用
于从管道读出数据，fd[1] 是管道的写端口，用于向管道写入数据。

返回值：0 调用成功；-1 调用失败。

5）sleep() 调用进程睡眠若干时间，之后唤醒。

格式：sleep(int t); 其中t为睡眠时间。

6）lockf() 用于对互斥资源加锁和解锁。

在本实验中，该调用的格式为：
lockf(fd[1],1,0)；/* 表示对管道的写入端口加锁。

lockf(fd[1],0,0)；/* 表示对管道的写入端口解锁。

7）write(fd[1],String,Length) 将字符串String的内容写入管道的写入口。

8）read(fd[0],String,Length) 从管道的读入口读出信息放入字符串String中。

4.程序流程
父进程：
1）创建管道；
2）创建子进程1；
3）创建子进程2；
4）等待从管道中读出子进程1写入的数据，并显示在屏幕上；
5）等待从管道中读出子进程2写入的数据，并显示在屏幕上；
6）退出。

子进程：
1）将管道的写入口加锁；
2）将信息“Child process n is sending message!”输入到变量OutPipe中，n=1，2；
3）将OutPipe中信息写入管道；
4）睡眠等待父进程从管道读出数据；
5）将管道的写入口解锁；
6）退出。

5.程序流程图
开始
创建管道
创建子进程
创建成功？N
Y
父进程返回？
N
锁定管道写端写信息入管道睡眠等待父进程
开锁
撤销子进程P1Y
创建子进程P2
创建成功？
N
Y
父进程返回？
Y
管道中是否有
消息
Y
读取管道消息
N
放弃处理机
锁定管道写端
向管道写入消息
睡眠等待父进程
锁定管道写端
撤销子进程P2
结束
N
6.程序源代码
#include <stdio.h>
#include <sys/types.h> #include <stdlib.h>
#include <sys/stat.h> #include <fcntl.h>
#include <error.h>
#include <wait.h>
#include <unistd.h>
int main()
{
int i,r,P1,P2,fd[2];//fd[1]写入端，fd[0]读取端
char buf[50],s[50];
pipe(fd);
while((P1=fork())==-1);
if(P1==0)
{
lockf(fd[1],1,0);
sprintf(buf,"child process P1 is sending messages! \n");
printf("child process P1! \n");
write(fd[1],buf,50);
sleep(5);
lockf(fd[1],0,0);
exit(0);
}
else
{
while((P2=fork())==-1);
if(P2==0)
{
lockf(fd[1],1,0);
sprintf(buf,"child process P2 is sending messages! \n");
printf("child process P2! \n");
write(fd[1],buf,50);
sleep(5);
lockf(fd[1],0,0);
exit(0);
}
int pid;
pid=wait(0);
printf("%d\n",pid);
if(r=read(fd[0],s,50)==-1)
printf("can't read pipe! \n");
else
printf("%s\n",s);
pid=wait(0);
printf("%d\n",pid);
if(r=read(fd[0],s,50)==-1)
printf("can't read pipe! \n");
else
printf("%s\n",s);
exit(0);
}
}
7.运行结果及其说明
运行结果如下图所示。

8.回答以下问题
①指出父进程与两个子进程并发执行的顺序，并说明原因。

答：父进程先创建子进程P1，然后子进程P1执行，P1执行完以后父进程执行并创建子进程P2，接着P2执行，P2执行完以后返回父进程，程序结束。

这是由进
程的同步机制决定的，因为只有子进程向管道写入信息后，父进程才能从管道
中读取消息；否则父进程调用wait()阻塞自己，将处理机交由子进程
②若不对管道加以互斥控制，会有什么后果？
答：对管道进行互斥控制，是为防止两个子进程对管道资源进行争夺而产生信息丢失或覆盖。

如果不加控制，那么可能一个子进程写入的信息还没来得及被父
进程读出，另一个子进程又向管道写入信息，那么之前的进程写入的信息将被
覆盖，父进程也就读不到之前进程传递来的信息了。

③说明你是如何实现父子进程之间的同步的。

答：父进程读出之前确定管道中有数据，若管道中没有数据，则父进程调用wait()
函数阻塞自身。

当子进程结束时，管道中已经有数据，父进程才执行。

子进程在写入之前要确定管道中的数据已经被父进程读出，否则不能写
入或者阻塞自己。

可以通过进程间的互斥来间接的办到。

因为子进程间的互斥，所以每个子进程在执行开始都对管道pipe 加锁，那么这样同时就只能有一个子进程向管道写入数据，并且子进程在向管道中写入数据后还要调用sleep()系统调用睡眠若干时间，那么这样就可以保证父进程能够从管道中读出数据。

然后下一子进程才能写入。

那么这样就保证了开头所说的子进程在写入之前要确定管道中的数据已经被父进程读出，否则不能写入或者阻塞自己。