Linux实验六：进程间通信（二）

---

一、实验目的

1、理解 POSIX 和 System V 提供的 IPC 相关概念；
2、理解管道所使用的文件描述符数组如何实现父子进程间的通信；
3、掌握 IPC 常用的函数，如 pipe，mkfifo 等。

二、实验内容

根据应用需要，父进程A需向子进程B传输消息 “Message here”，请使用管道技术完成此功能。

三、实验环境

虚拟机软件：VMware 16 Pro
Linux操作系统版本：CentOS-7-64位

四、参考代码

1. #include<stdio.h>
2. #include<stdlib.h>
3. #include<string.h>
4. #include<unistd.h>
5. #include<sys/types.h>
7. int main(int argc,char* argv[]){
8. pid_t pid;
9. int fds[2];
10. char buf[256];
11. const char data[]="Message here!";
12. int len=0;
14. memset((void*)buf,0,sizeof(buf));
16. //create pipe
17. if(pipe(fds)<0){
18. printf("Pipe create error!\n");
19. exit(-1);
20. }
22. //create child process
23. if((pid=fork())==0){
24. close(fds[1]);
25. if((len=read(fds[0],buf,strlen(data)))!=-1){
26. printf("B read from A:%s!\n",buf);
27. }
28. close(fds[0]);
29. }else if(pid>0){
30. close(fds[0]);
31. if((len=write(fds[1],data,strlen(data)))!=-1){
32. printf("A write to B:%s!\n",data);
33. }
34. close(fds[1]);
35. waitpid(pid,NULL,0);
36. exit(0);
37. }else{
38. printf("Create process error!\n");
39. exit(-1);
40. }
41. }

复制代码

五、实验步骤

步骤1. 编辑源代码test6.c

源代码test6.c内容见上述参考代码。

1. mkdir test6
2. cd test6
3. vim test6.c

复制代码

这段代码是一个简单的父子进程间通信的例子，使用了Linux系统调用中的管道（pipe）和进程创建（fork）。

• 在main函数中，定义了一些变量，包括一个pid_t类型的pid变量用于存储进程ID，一个整型数组fds用于存储管道的文件描述符，一个字符数组buf用于存储读取的数据，一个常量字符数组data存储要写入管道的数据，以及一个整型变量len用于存储读取或写入的字节数。

• 使用memset将buf数组初始化为0，以确保没有垃圾数据残留。

• 调用pipe函数创建管道，如果失败，则打印错误信息并退出程序。

• 调用fork函数创建子进程。如果fork返回值为0，表示当前代码正在子进程中执行；如果大于0，表示当前代码正在父进程中执行；如果返回-1，表示创建进程失败。

• 如果在子进程中，关闭了fds数组的写端（fds[1]），然后通过read函数从管道的读端（fds[0]）读取数据到buf数组中，并打印读取的数据。

• 如果在父进程中，关闭了fds数组的读端（fds[0]），然后通过write函数将data数组中的数据写入管道的写端（fds[1]），并打印写入的数据。

• 在父进程中调用waitpid函数等待子进程退出。

• 父子进程均关闭了管道的相应端口，并退出程序。

这段代码实现了父子进程间的单向通信，父进程向子进程写入数据，子进程读取并打印收到的数据。

步骤2. 编译源代码test6.c

1. gcc test6.c -o test6 -g

复制代码

步骤3. 运行可执行程序test6

1. ./test6

复制代码

步骤4. 进一步调试源代码test6.c

（1）将父进程发给子进程的消息“Message here”，改为发送：自己的学号和姓名（使用 \n 分隔）；

1. pid_t pid;
2. int fds[2];
3. char buf[256];
4. const char data[]="\n学号:123456789\n姓名:zhc";
5. int len=0;

复制代码

（2）子进程运行结束前，输出“子进程在这里结束\n”；

1. if((pid=fork())==0){
2. close(fds[1]);
3. if((len=read(fds[0],buf,strlen(data)))!=-1){
4. printf("B read from A:%s!\n",buf);
5. }
6. close(fds[0]);
7. printf("子进程在这里结束\n");
8. }

复制代码

（3）父进程运行结束前，输出“父进程结束\n”。

1. else if(pid>0){
2. close(fds[0]);
3. if((len=write(fds[1],data,strlen(data)))!=-1){
4. printf("A write to B:%s!\n",data);
5. }
6. close(fds[1]);
7. waitpid(pid,NULL,0);
8. printf("父进程结束\n");
9. exit(0);
10. }

复制代码

再重新编译test6.c，并运行可行性文件test6。结果如下图所示：

六、实验结果

调试后的最终源代码test6.c：

1. #include<stdio.h>
2. #include<stdlib.h>
3. #include<string.h>
4. #include<unistd.h>
5. #include<sys/types.h>
7. int main(int argc,char* argv[]){
8. pid_t pid;
9. int fds[2];
10. char buf[256];
11. const char data[]="\n学号:123456789\n姓名:zhc";
12. int len=0;
14. memset((void*)buf,0,sizeof(buf));
16. //create pipe
17. if(pipe(fds)<0){
18. printf("Pipe create error!\n");
19. exit(-1);
20. }
22. //create child process
23. if((pid=fork())==0){
24. close(fds[1]);
25. if((len=read(fds[0],buf,strlen(data)))!=-1){
26. printf("B read from A:%s!\n",buf);
27. }
28. close(fds[0]);
29. printf("子进程在这里结束\n");
30. }else if(pid>0){
31. close(fds[0]);
32. if((len=write(fds[1],data,strlen(data)))!=-1){
33. printf("A write to B:%s!\n",data);
34. }
35. close(fds[1]);
36. waitpid(pid,NULL,0);
37. printf("父进程结束\n");
38. exit(0);
39. }else{
40. printf("Create process error!\n");
41. exit(-1);
42. }
43. }

复制代码

实验运行结果如下图所示。

七、实验总结

  通过这次实验，我对进程间通信和Linux系统调用有了更深入的认识。这个简单的例子展示了如何使用管道（pipe）和进程创建（fork）来实现父子进程之间的通信，同时也揭示了一些潜在的问题和注意事项。
  首先，我对管道的理解得到了加深。管道是一种进程间通信的机制，它可以在父子进程之间传递数据。在这个例子中，通过调用pipe函数创建了一个管道，它返回了两个文件描述符，分别用于读取和写入数据。这种单向的通信方式确保了数据的顺序性和可靠性。其次，我对进程创建（fork）有了更清晰的认识。fork函数用于创建一个新的进程，新的进程是调用进程的副本，但有着不同的进程ID。在这个例子中，通过fork函数创建了一个子进程，子进程和父进程共享了文件描述符表，但各自有独立的内存空间，因此可以通过管道进行通信。
  在实验过程中，我也遇到了一些问题。例如，父进程在写入数据后调用了waitpid函数等待子进程退出，这样可以确保子进程在父进程之后退出，防止出现僵尸进程。另外，在子进程中读取数据时，我发现可以使用read函数的返回值来判断是否成功读取数据，这样可以更加健壮地处理错误。
  通过这个实验，我不仅加深了对进程间通信和Linux系统调用的理解，还学会了如何使用管道和进程创建来实现简单的父子进程通信。我相信这些知识将在未来的编程实践中发挥重要作用，让我能够更加高效地编写并理解涉及进程间通信的程序。