实验三 进程的管道通信实验
实验3 进程的管道通信实验
父进程和子进程间管道通信示例
• 例1：用C语言编写一个程序，建立一个 pipe，同时父进程生成一个子进程，子进向 pipe中写入一字符串，父进程从pipe中读出 该字符串。
程序
# include <stdio.h> main() { int x, fd[2]; char buf[30],s[30]; pipe(fd); /*创建管道*/ while((x=fork()) = = -1); /*创建子进程失败时，循环*/ if(x = = 0) { sprintf(buf, ”This is an example\n”); write(fd[1],buf,30); /*把buf中字符写入管道*/ exit(0); } else { wait(0); read(fd[0],s,30); /*父进程读管道中字符*/ printf(“%s”,s); } }
管道的实现原理（1）
• 利用linux提供的系统调用pipe，可建立一 条同步通信管道。其格式为： pipe(fd) int fd[2]; • fd[ห้องสมุดไป่ตู้]为写入端，fd[0]为读出端。
管道的实现原理（2）
• 通过文件系统的系统调用write和read进行管 道的写和读；
– 管道按FIFO（先进先出）方式传送消息 – 只能单向传送消息，进程间双向通信，通常需要 两个管道； – 只适用于父子进程之间或父进程安排的各个子进 程之间。
实验3 进程的管道通信实验
实验目的
• 1、了解什么是管道 • 2、熟悉UNIX/LINUX支持的管道通信 方式
实验内容
• 编写程序实现进程的管道通信。用系统调 用pipe( )建立一管道，二个子进程P1和P2 分别向管道各写一句话： Child 1 is sending a message! Child 2 is sending a message! 父进程从管道中读出二个来自子进程的信 息并显示（要求先接收P1，后P2）。
操作系统实验三进程的管道通信
实验三进程的管道通信一、实验目的：（1）加深对进程概念的理解，明确进程和程序的区别；（2）学习进程创建的过程，进一步认识并发执行的实质；（3）分析进程争用资源的现象，学习解决进程互斥的方法；（4）学习解决进程同步的方法；（5）掌握Linux系统进程间通过管道通信的具体实现方法。
二、实验内容及要求：（1）使用系统调用pipe()建立一条管道线，两个子进程分别向管道写一句话（写的内容自己定，但要有该进程的一些信息）；（2）父进程从管道中读出来自两个子进程的消息，显示在屏幕上；（3）要求：父进程首先接收子进程p1发来的消息，然后再接收子进程p2发来的消息；（4）两个子进程要并发执行；（5）实现管道的互斥使用。
当一个子进程正在对管道进行写操作时，另一个欲写入管道的子进程必须等待。
使用系统调用lockf(fd[1],1,0)实现对管道的加锁操作，用lockf(fd[1],0,0)解除对管道的锁定；（6）实现父子进程的同步，当父进程试图从一空管道中读取数据时，便进入等待状态，直到子进程将数据写入管道返回后，才将其唤醒。
三、实现：相关的系统调用fork() 用于创一个子进程。
格式：int fork();返回值：在子进程中返回0；在父进程中返回所创建的子进程的ID值；当返回-1时，创建失败。
wait() 常用来控制父进程与子进程的同步。
在父进程中调用wait()，则父进程被阻塞，进入等待队列，等待子进程结束。
当子进程结束时，父进程从wait()返回继续执行原来的程序。
返回值：大于0时，为子进程的ID值；等于-1时，调用失败。
exit() 是进程结束时最常调用的。
格式：void exit( int status); 其中，status为进程结束状态。
pipe() 用于创建一个管道格式：pipe(int fd);其中fd是一个由两个数组元素fd[0]和fd[1]组成的整型数组，fd[0]是管道的读端口，用于从管道读出数据,fd[1]是管道的写端口，用于向管道写入数据。
进程实验-进程间通信(管道、消息、共享内存、软中断)
进程实验3 Linux 进程间通信一、软中断信号的处理，实现同一用户的各进程之间的通信。
●相关的系统调用⏹kill(pid ,sig)：发送信号⏹signal（sig, func）：指定进程对信号sig的处理行为是调用函数func。
●程序清单#include <unistd.h>#include <stdio.h>#include <signal.h>void waiting();void stop();int wait_mark;main(){int p1,p2;while((p1=fork())==-1);if(p1>0){while((p2=fork())==-1);if(p2>0){ printf("parent\n");/*父进程在此完成某个操作、或接收到用户从键盘输入的特殊按键命令后发出下面的信号。
这里省略。
*/kill(p1,16);kill(p2,17);wait(0);wait(0);printf("parent process id killed! \n");exit(0);}else/* p2==0*/{printf("p2\n");wait_mark=1;signal(17,stop);waiting();printf("child process 2 is killed by parent! \n");exit(0);}}else/*p1==0*/{printf("p1\n");wait_mark=1;signal(16,stop);waiting();printf("child process 1 is kelled by parent! \n");exit(0);}}void waiting(){while(wait_mark!=0);}void stop(){wait_mark=0;}●输入并运行此程序，分析程序的运行结果。
实验三、进程通信(一) ——管道及共享内存
（1）阅读以上父子进程利用管道进行通信的例子（例1），写出程序的运行结果并分析
实验代码：
#include<stdio.h>
main()
{ int x,fd[2];
char buf[30],s[30];
pipe(fd);
while ((x=fork())==-1);
if (x==0)
}
write(fe[1],s,30);
wait(0);
}
运行结果：
（3）阅读例2的程序，运行一次该程序，然后用ipcs命令查看系统中共享存储区的情况，再次执行该程序，再用ipcs命令查看系统中共享内存的情况，对两次的结果进行比较，并分析原因。最后用ipcrm命令删除自己建立的共享存储区。（有关ipcs和ipcrm介绍见后面一页）
addr=shmat(shmid,0,0);/*挂接，并得到共享区首地址*/
printf ("addr 0x%x\n",addr);
pint=(char *)addr;
for (i='a';i<='e';i++) *pint++=i;
pause();/*等待接收进程读*/
}
cleanup()
{
shmctl(shmid,IPC_RMID,0);
（2）每个同学登陆两个窗口，先在一个窗口中运行例3程序1（或者只登陆一个窗口，先在该窗口中以后台方式运行程序1），然后在另一个窗口中运行例3程序2，观察程序的运行结果并分析。运行结束后可以用ctrl+c结束程序1的运行。
（3）编写程序：使用系统调用shmget()，shmat()，shmdt()，shmctl()，编制程序。要求在父进程中生成一个30字节长的私有共享内存段。接下来，设置一个指向共享内存段的字符指针，将一串大写字母写入到该指针指向的存贮区。调用fork()生成子进程，让子进程显示共享内存段中的内容。接着，将大写字母改成小写，子进程修改共享内存中的内容。之后，子进程将脱接共享内存段并退出。父进程在睡眠5秒后，在此显示共享内存段中的内容（此时已经是小写字母）。
实验三_进程间通信 (1)
实验三线程控制和进程间通信一、实验目的通过Linux管道通信机制、消息队列通信机制的使用，加深对不同类型的进程通信方式的理解。
二、实验内容：1.熟悉Linux的管道通信机制2.熟悉Linux的消息队列通信机制三、思考1.有名管道和无名管道之间有什么不同？2.管道的读写与文件的读写有什么异同？3.Linux消息队列通信机制中与教材中的消息缓冲队列通信机制存在哪些异同？四、实验指导<一>Linux管道通信机制管道是所有UNIX都提供的一种进程间通信机制，它是进程之间的一个单向数据流，一个进程可向管道写入数据，另一个进程则可以从管道中读取数据，从而达到进程通信的目的。
1.无名管道无名管道通过pipe()系统调用创建，它具有如下特点：(1)它只能用于具有亲缘关系的进程（如父子进程或者兄弟进程）之间的通信。
(2)管道是半双工的，具有固定的读端和写端。
虽然pipe()系统调用返回了两个文件描述符，但每个进程在使用一个文件描述符之前仍需先将另一个文件描述符关闭。
如果需要双向的数据流，则必须通过两次pipe()建立起两个管道。
(3)管道可以看成是一种特殊的文件，对管道的读写与文件的读写一样使用普通的read、write等函数，但它不是普通的文件，也不属于任何文件系统，而只存在于内存中。
2.pipe系统调用（1）函数原型#include <unistd.h>int pipe(int filedes[2]);（2）参数filedes参数是一个输出参数，它返回两个文件描述符，其中filedes[0]指向管道的读端，filedes[1]指向管道的写端。
（3）功能pipe在内存缓冲区中创建一个管道，并将读写该管道的一对文件描述符保存在filedes所指的数组中，其中filedes[0]用于读管道，filedes[1]用于写管道。
（4）返回值成功返回0；失败返回-1，并在error中存入错误码。
（5）错误代码EMFILE：进程使用的文件描述符过多ENFILE ：系统文件表已满EFAULT ：非法参数filedes3.无名管道的阻塞型读写管道缓冲区有4096B的长度限制，因此，采用阻塞型读写方式时，当管道已经写满时，写进程必须等待，直到读进程取走信息为止。
通信管道实验报告(3篇)
第1篇一、实验目的1. 理解通信管道的概念和作用。
2. 掌握管道的创建、使用和销毁方法。
3. 学习管道在进程间通信中的应用。
4. 熟悉管道的同步机制。
二、实验原理管道（Pipe）是UNIX系统中实现进程间通信（IPC）的一种古老且常用的方法。
它允许一个进程向另一个进程发送数据。
管道通常由两个端点组成：一个用于写入数据，另一个用于读取数据。
管道可以用于父子进程之间的通信，也可以用于兄弟进程之间的通信。
三、实验内容1. 创建管道：使用`pipe()`系统调用创建管道。
2. 写入数据：使用`write()`系统调用向管道写入数据。
3. 读取数据：使用`read()`系统调用从管道读取数据。
4. 管道的同步：使用`select()`或`poll()`等系统调用来实现管道的同步。
5. 管道的销毁：使用`close()`系统调用销毁管道。
四、实验步骤1. 创建管道：```cint pipefd[2];if (pipe(pipefd) == -1) {perror("pipe");exit(EXIT_FAILURE);}```2. 创建子进程：```cpid_t pid = fork();if (pid == -1) {perror("fork");exit(EXIT_FAILURE);}```3. 在子进程中写入数据：```cif (pid == 0) {close(pipefd[0]); // 关闭读端write(pipefd[1], "Hello, world!\n", 14); close(pipefd[1]); // 关闭写端exit(EXIT_SUCCESS);}```4. 在父进程中读取数据：```cclose(pipefd[1]); // 关闭写端char buffer[1024];read(pipefd[0], buffer, sizeof(buffer));printf("Received: %s\n", buffer);close(pipefd[0]); // 关闭读端```5. 同步管道：```cfd_set readfds;FD_ZERO(&readfds);FD_SET(pipefd[0], &readfds);select(pipefd[0] + 1, &readfds, NULL, NULL, NULL);```6. 销毁管道：```cclose(pipefd[0]);close(pipefd[1]);```五、实验结果1. 创建管道成功。
实验三 进程间的通信
实验三进程间的通信1、实验目的学习如何利用管道机制、消息缓冲队列进行进程间的通信，并加深对上述通信机制的理解。
2、实验内容（1）了解系统调用pipe()、msgget()、msgsnd()、msgrcv()的功能和实现过程。
（2）编写一段程序，使其用管道来实现父子进程之间的进程通信。
子进程向父进程发送自己的进程标识符，以及字符串“is sending a message to parent!”。
父进程则通过管道读出子进程发来的消息，将消息显示在屏幕上，然后终止。
（3）编写一段程序，使用消息缓冲队列来实现client进程和server进程之间的通信。
server进程先建立一个关键字为SVKEY （如75）的消息队列，然后等待接收类型为REQ（如1）的消息；在收到请求消息后，它便显示字符串“serving for client”和接收到的client进程的进程标识数，表示正在为client进程服务；然后再向client进程发送一应答消息，该消息类型是client 进程的进程标识数，而正文则是server进程自己的标识数。
client进程则向消息队列发送类型为REQ的消息（消息的正文为自己的进程标识数）以取得server进程的服务，并等待server 进程发来的应答；然后显示字符串“receive reply form”和接收到的server进程的标识符。
1、client.c2、server.c3、思考题上述通信机制各有什么特点？它们分别适合于何种场合？答：管道通信的特点：（1）管道是半双工的，数据只能向一个方向流动；需要双方通信时，需要建立起两个管道；（2）只能用于父子进程或者兄弟进程之间（具有亲缘关系的进程）；（3）单独构成一种独立的文件系统：管道对于管道两端的进程而言，就是一个文件，但它不是普通的文件，它不属于某种文件系统，而是自立门户，单独构成一种文件系统，并且只存在与内存中。
（4）数据的读出和写入：一个进程向管道中写的内容被管道另一端的进程读出。
实验三、进程通信一 ——管道及共享内存
操作系统实验报告实验三、进程通信（一）——管道及共享存一、实验目的1）加深对管道通信的了解2）掌握利用管道进行通信的程序设计3）了解共享存通信的程序设计方法4）了解和熟悉Linux支持的共享存储区机制二、实验容任务一、（1）阅读以上父子进程利用管道进行通信的例子（例1），写出程序的运行结果并分析。
（2）编写程序：父进程利用管道将一字符串交给子进程处理。
子进程读字符串，将里面的字符反向后再交给父进程，父进程最后读取并打印反向的字符串。
任务二、（1）阅读例2的程序，运行一次该程序，然后用ipcs命令查看系统中共享存储区的情况，再次执行该程序，再用ipcs命令查看系统中共享存的情况，对两次的结果进行比较，并分析原因。
最后用ipcrm命令删除自己建立的共享存储区。
（有关ipcs和ipcrm介绍见后面一页）（2）每个同学登陆两个窗口，先在一个窗口中运行例3程序1（或者只登陆一个窗口，先在该窗口中以后台方式运行程序1），然后在另一个窗口中运行例3程序2，观察程序的运行结果并分析。
运行结束后可以用ctrl+c结束程序1的运行。
（3）编写程序：使用系统调用shmget()，shmat()，shmdt()，shmctl()，编制程序。
要求在父进程中生成一个30字节长的私有共享存段。
接下来，设置一个指向共享存段的字符指针，将一串大写字母写入到该指针指向的存贮区。
调用fork()生成子进程，让子进程显示共享存段中的容。
接着，将大写字母改成小写，子进程修改共享存中的容。
之后，子进程将脱接共享存段并退出。
父进程在睡眠5秒后，在此显示共享存段中的容（此时已经是小写字母）。
三、代码及运行结果分析（1）阅读以上父子进程利用管道进行通信的例子（例1），写出程序的运行结果并分析实验代码：#include<stdio.h>main(){ int x,fd[2];char buf[30],s[30];pipe(fd);while ((x=fork())==-1);if (x==0){close(fd[0]);printf("Child Process!\n");strcpy(buf,"This is an example\n");write(fd[1],buf,30);exit(0);}else{close(fd[1]);printf("Parent Process!\n");read(fd[0],s,30);printf("%s\n",s);}}运行结果：分析：调用pipe(fd);创建一个管道后，接着调用fork()函数产生两个进程，首先开始执行子进程，关闭管道出口，通过管道入口向管道中写入容。
进程的管道通信实验报告
进程的管道通信实验报告一、实验目的本实验旨在通过实际操作，深入理解进程间通信（IPC）的原理，掌握管道通信的实现方法，提高对操作系统进程管理的理解。
二、实验环境实验环境为Linux操作系统，使用Shell脚本进行进程的管道通信实验。
三、实验内容1. 创建两个Shell脚本文件，分别命名为sender.sh和receiver.sh。
2. 在sender.sh中，编写一个简单的程序，用于向管道中写入数据。
程序包括一个无限循环，每次循环中随机生成一个数字并写入管道。
3. 在receiver.sh中，编写一个简单的程序，用于从管道中读取数据。
程序同样包括一个无限循环，每次循环中从管道中读取一个数字并输出。
4. 使用Shell命令将sender.sh和receiver.sh链接起来，实现进程间的管道通信。
四、实验过程1. 打开两个终端窗口，分别用于运行sender.sh和receiver.sh。
2. 在第一个终端窗口中，输入命令“bash sender.sh”运行sender.sh脚本。
该脚本将创建一个无限循环，每次循环中随机生成一个数字并写入管道。
3. 在第二个终端窗口中，输入命令“bash receiver.sh”运行receiver.sh脚本。
该脚本将创建一个无限循环，每次循环中从管道中读取一个数字并输出。
4. 观察两个终端窗口的输出，可以看到sender.sh进程向管道中写入的数字被receiver.sh进程读取并输出。
五、实验总结通过本次实验，我们成功实现了进程间的管道通信。
在实验过程中，我们深入了解了进程间通信的原理和实现方法，掌握了管道通信的基本操作。
通过实际操作，我们更好地理解了操作系统中进程管理、进程间通信的相关知识。
同时，我们也发现了一些不足之处，例如在程序中没有添加异常处理机制等。
在今后的学习中，我们将继续深入探索进程间通信的相关知识，提高自己的编程技能和系统设计能力。
进程的管道通信实验总结
进程的管道通信实验是一个非常有用的实验，它允许两个进程之间进行数据交换。
这个实验主要涉及到了管道、管道缓冲区以及进程之间的通信机制。
以下是对这个实验的总结：
1. 管道的概念和作用：
管道是一种用于进程间通信的机制，它允许两个进程之间进行数据交换。
在管道通信实验中，我们创建了一个管道，并使用它来在两个进程之间传递数据。
管道的作用是连接两个进程，使得它们可以相互发送和接收数据。
2. 管道缓冲区：
管道缓冲区是管道中的一个重要概念。
当一个进程向管道写入数据时，数据会被写入缓冲区中，等待另一个进程读取。
当缓冲区中的数据被读取后，缓冲区中的数据会被移除，为新的数据腾出空间。
3. 进程间的通信：
在管道通信实验中，我们创建了两个进程，并使用管道来在它们之间进行通信。
一个进程向管道写入数据，另一个进程从管道读取数据。
通过这种方式，两个进程可以相互发送和接收数据。
4. 实验中的问题和解决方案：
在实验中，我们遇到了一些问题，如管道中的数据读写错误、进程间的通信问题等。
为了解决这些问题，我们采取了一些措施，如检查数据的读写是否正确、确保进程间的通信畅通等。
5. 实验的意义和收获：
通过这个实验，我们深入了解了进程间通信的概念和机制，并掌握了管道通信的基本原理和方法。
此外，我们还学会了如何解决实验中遇到的问题，提高了我们的编程能力和解决问题的能力。
总之，进程的管道通信实验是一个非常有意义的实验，它让我们深入了解了进程间通信的原理和方法。
通过这个实验，我们不仅掌握了相关的知识和技能，还提高了我们的编程能力和解决问题的能力。
3 操作系统课程设计 进程通讯 管道
该函数使用头文件如下：
2、read( )
系统调用格式
#include <unistd.h> #inlcude <signal.h> #include <stdio.h>
read(fd,buf,nbyte) 功能：从 fd 所指示的文件中读出 nbyte 个字节的数据，并将它们送至由指针 buf 所
指示的缓冲区中。如该文件被加锁，等待，直到锁打开为止。
参数定义
3、write( )
系统调用格式
int read(fd,buf,nbyte); int fd; char *buf; unsigned nbyte;
write(fd,buf,nbyte) 功能：把 nbyte 个字节的数据，从 buf 所指向的缓冲区写到由 fd 所指向的文件中。如
实验指导
一、什么是管道 UNIX 系统在 OS 的发展上，最重要的贡献之一便是该系统首创了管道（pipe）。这也 是 UNIX 系统的一大特色。 所谓管道，是指能够连接一个写进程和一个读进程的、并允许它们以生产者—消费者 方式进行通信的一个共享文件，又称为 pipe 文件。由写进程从管道的写入端（句柄 1）将 数据写入管道，而读进程则从管道的读出端（句柄 0）读出数据。
实验手册内容：
实验目的
1、了解什么是管道 2、熟悉 UNIX/LINUX 支持的管道通信方式
实验三 进程通信 （二）进程的管道通信实验
实验内容
编写程序实现进程的管道通信。用系统调用 pipe( )建立一管道，二个子进程 P1 和 P2 分别向管道各写一句话：
Child 1 is sending a message! Child 2 is sending a message! 父进程从管道中读出二个来自子进程的信息并显示（要求先接收 P1，后 P2）。
操作系统实验三(进程通信)
暨南大学本科实验报告专用纸课程名称《操作系统原理实验》成绩评定实验项目名称进程通信指导教师戴红实验项目编号0806002903 实验项目类型综合型实验地点学生姓名蔡高成学号2007052431学院国际商学院系企业管理专业信息管理与信息系统实验时间年月日下午温度℃湿度一、实验目的学习如何利用管道机制或消息缓冲队列进行进程间的通信，并加深对上述通信机制的理解。
提高学生分析问题和解决问题的能力，并学习撰写规范的科学研究报告。
二、实验环境及设备（一）实验室名称：计算机实验室（二）主要仪器设备：PC机、Linux操作系统环境三、实验内容编写一段程序，使用管道来实现父子进程之间的进程通信。
子进程项父进程发送自己的进程表示符，以及某字符串。
父进程则通过管道读出子进程发来的消息，将消息显示在屏幕上，然后终止。
四、实验调试分析1、实验函数说明（1）pipe头文件：#include<unistd.h>定义函数：int pipe(int pipedes[2]);函数说明：pipe()会建立管道,并将文件描述词由参数pipedes 数组返回。
pipedes[0]为管道里的读取端，所以pipe用read调用的pipedes[1]则为管道的写入端。
写进程A pipedes[1]返回值: 若成功则返回零,否则返回-1,错误原因存于errno 中。
错误代码:EMFILE 进程已用完文件描述词最大量ENFILE 系统已无文件描述词可用。
EFAULT 参数pipedes 数组地址不合法。
（2）sprintf函数功能：把格式化的数据写入某个字符串头文件：#include <stdio.h>函数原型：int sprintf( char *buffer, const char *format [, argument] … );返回值：字符串长度（strlen）（3）flock头文件： #include<sys/file.h>定义函数： int flock(int fd,int operation);函数说明： flock()会依参数operation所指定的方式对参数fd所指的文件做各种锁定或解除锁定的动作。
进程之间的通信实验
实验：进程之间的通信管道1．Pipe函数与进程通信下面实验为使用管道进行父子进程间通信。
程序首先判断参数是否合法，因为输入的字符将从父进程通过发送到子进程中。
然后，调用pipe函数创建父子进程用于通信的管道。
使用fork函数创建子进程时，子进程会获得与父进程相同的资源，其中包括文件描述符信息。
因此，调用fork函数须在pipe函数调用前。
当父子进程通过管道进行通信时，files[1]为用于数据写入的文件描述符.因此,在子进程中,要读取管道中的数据可以调用read函数，而读取得文件描述符为files[0]。
对于父进程而言，写入数据需要调用write 函数，要写入的文件描述为files[1]。
#include <stdio.h>#include <unistd.h>int main(int argc,char* argv[]){int f_des[2];int pid;char msg[BUFSIZ];if(argc!=2){printf("Usage: %s message\n",argv[0]);return 1;}if(pipe(f_des)==-1){perror("cannot create the IPC pipe");return 1;}pid=fork();if(pid==-1){perror("cannot create new process");return 1;}else if(pid==0){close(f_des[1]);if(read(f_des[0],msg,BUFSIZ)==-1){perror("child process cannot read data from pipe");return 1;}elseprintf("in child process, receive message: %s\n",msg);_exit(0);}else {close(f_des[0]);if(write(f_des[1],argv[1],strlen(argv[1]))==-1){perror("parent process cannot write data to pipe");return 1;}elseprintf("in parent process, send message: %s\n",argv[1]);wait(NULL);_exit(0);}return 0;}2. Shell管道重订向的实现实现了在SHELL中的两个命令的组合。
操作系统实验三进程的管道通信
操作系统实验三进程的管道通信操作系统中的进程通信是指进程之间通过一定机制进行信息传递和交换的过程。
而管道是常用的进程间通信(IPC)机制之一，它提供了一种半双工的通信方式，用于在具有亲缘关系的进程之间进行通信。
本实验以Linux系统为例，介绍进程的管道通信。
一、进程间通信(IPC)概述进程之间的通信是操作系统的重要功能之一，它使得不同进程能够共享信息、协调工作。
Linux系统提供了多种进程间通信的方式，如管道、消息队列、信号、共享内存等。
其中，管道是最简单、最常用的一种进程间通信方式。
二、管道的概念与原理1.管道的概念管道是一种特殊的文件，用于实现具有亲缘关系的进程之间的通信。
整个管道可以看作是一个字节流，其中写入的数据可以被读取。
管道通常是半双工的，即数据只能从一个进程流向另一个进程，而不能反向流动。
2.管道的原理管道的内部实现是通过操作系统的缓冲区来完成的。
当一个进程往管道写入数据时，数据被放置在写管道的缓冲区中。
另一个进程从管道中读取数据时，数据被从读管道的缓冲区中取出。
如果写管道的缓冲区为空，写操作将会阻塞，直到有数据被写入为止。
同样，如果读管道的缓冲区为空，读操作将会阻塞，直到有数据可读为止。
三、管道的使用步骤1.打开管道在Linux系统中，使用`pipe`系统调用来创建管道。
它接受一个包含两个整数的参数数组，返回0表示成功，负数表示失败。
成功创建管道后，会得到两个文件描述符，分别代表读管道和写管道。
2.进程间通信在有亲缘关系的进程中，可以使用`fork`系统调用来创建一个子进程。
父进程和子进程都可以使用管道进行读写操作。
父进程可以关闭写管道描述符，子进程关闭读管道描述符，即父进程只负责写入数据，子进程负责读取数据。
3.写入数据父进程在写管道描述符上调用`write`函数来向管道写入数据。
该函数的返回值为成功写入的字节数，返回-1表示写入失败。
4.读取数据子进程在读管道描述符上调用`read`函数来从管道读取数据。
操作系统实验三进程的管道通信
操作系统实验三进程的管道通信Company number：【0089WT-8898YT-W8CCB-BUUT-202108】实验三进程的管道通信一、实验目的：（1）加深对进程概念的理解，明确进程和程序的区别；（2）学习进程创建的过程，进一步认识并发执行的实质；（3）分析进程争用资源的现象，学习解决进程互斥的方法；（4）学习解决进程同步的方法；（5）掌握Linux系统进程间通过管道通信的具体实现方法。
二、实验内容及要求：（1）使用系统调用pipe()建立一条管道线，两个子进程分别向管道写一句话（写的内容自己定，但要有该进程的一些信息）；（2）父进程从管道中读出来自两个子进程的消息，显示在屏幕上；（3）要求：父进程首先接收子进程p1发来的消息，然后再接收子进程p2发来的消息；（4）两个子进程要并发执行；（5）实现管道的互斥使用。
当一个子进程正在对管道进行写操作时，另一个欲写入管道的子进程必须等待。
使用系统调用lockf(fd[1],1,0)实现对管道的加锁操作，用lockf(fd[1],0,0)解除对管道的锁定；（6）实现父子进程的同步，当父进程试图从一空管道中读取数据时，便进入等待状态，直到子进程将数据写入管道返回后，才将其唤醒。
三、实现：相关的系统调用fork() 用于创一个子进程。
格式：int fork();返回值：在子进程中返回0；在父进程中返回所创建的子进程的ID值；当返回-1时，创建失败。
wait() 常用来控制父进程与子进程的同步。
在父进程中调用wait()，则父进程被阻塞，进入等待队列，等待子进程结束。
当子进程结束时，父进程从wait()返回继续执行原来的程序。
返回值：大于0时，为子进程的ID值；等于-1时，调用失败。
exit() 是进程结束时最常调用的。
格式：void exit( int status); 其中，status为进程结束状态。
pipe() 用于创建一个管道格式：pipe(int fd);其中fd是一个由两个数组元素fd[0]和fd[1]组成的整型数组，fd[0]是管道的读端口，用于从管道读出数据,fd[1]是管道的写端口，用于向管道写入数据。
实验3 进程通信
实验三进程通信
1.实验类型：设计性实验
2.实验目的：
了解和熟悉LINUX的管道通信、软中断通信、SOCKET通信等
3.实验内容：
练习一三个子进程和父进程的管道通信。
（必做）
编写一个程序，建立一个管道。
同时，父进程生成子进程P1，P2，P3这三个子进程分别向管道中写入消息（消息由键盘输入），父进程将消息读出。
练习二软中断一（必做）
编写一个程序循环输出“how are you?”，当键盘输入Ctrl+C时终止，当输出次数不超过5000次时在此过程中使用Ctrl+C不能中断显示，5000次后才能用Ctrl+C中断显示，然后输出“Byebye”.
练习三软中断二（选做）
使用软中断实现父子进程同步，父进程先输出A，然后子进程输出B。
练习四编程实现基于SOCKET的进程间通信，实现网络中不同终端间可相互通信。
（选做）
要求：分别编写服务器端和客户端两个程序（使用线程），编译后分别在不同终端运行程序，二者间可相互进行通信。
实验三_进程间的通信
本科实验报告专用纸课程名称操作系统原理成绩评定实验项目名称进程间的通信指导教师实验项目编号实验项目类型实验地点学生姓名学号学院系专业实验时间年月日上午～月日上午温度℃湿度一、实验目的和要求1.实验目的：1.学习如何利用管道机制或消息缓冲队列进行进程间的通信，并加深对上述通信机制的理解。
提高学生分析问题和解决问题的能力，并学习撰写规范的科学研究报告（论文）。
2.实验要求：了解系统pipe(),msgsnd(),msgrcv()的功能和实现过程。
二、实验原理和主要内容1.实验内容：（1）编写一段程序，使用管道来实现父子进程之间的进程通信。
子进程向父进程发送自己的进程表示符，以及某字符串。
父进程则通过管道读出子进程发来的消息，将消息显示在屏幕上，然后终止。
（2）编写一段程序，使其用消息缓冲队列来实现client和server 进程之间的通信。
2.实验原理：（使用的系统调用命令说明或算法及程序详细设计）3.实验函数说明（1）包含头文件#include <sys/types.h>#include <sys/ipc.h>#include <sys/msg.h>（2）msgsnd()函数int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);//将消息送入消息队列参数：msqid：消息队列的识别码。
msgp：指向消息缓冲区的指针，此位置用来暂时存储发送和接收的消息，是一个用户可定义的通用结构，形态如下struct msgbuf {long mtype; /* 消息类型，必须> 0 */char mtext[1]; /* 消息文本*/};msgsz：消息的大小。
msgtyp：从消息队列内读取的消息形态。
如果值为零，则表示消息队列中的所有消息都会被读取。
msgflg：用来指明核心程序在队列没有数据的情况下所应采取的行动。
实验三 进程的管道通信实验
实验三进程的管道通信一、实验目的（1）了解什么是管道（2）熟悉UNIX/LINUX支持的管道通信方式二、实验学时4学时三、实验内容编写程序实现进程的管道通信。
用系统调用pipe( )建立一管道，二个子进程P1和P2分别向管道各写一句话：Child 1 is sending a message!Child 2 is sending a message!父进程从管道中读出二个来自子进程的信息并显示（要求先接收P1，后P2）。
四、实验指导一、什么是管道UNIX系统在OS的发展上，最重要的贡献之一便是该系统首创了管道（pipe）。
这也是UNIX系统的一大特色。
所谓管道，是指能够连接一个写进程和一个读进程的、并允许它们以生产者—消费者方式进行通信的一个共享文件，又称为pipe文件。
由写进程从管道的写入端（句柄1）将数据写入管道，而读进程则从管道的读出端（句柄0）读出数据。
1、有名管道一个可以在文件系统中长期存在的、具有路径名的文件。
用系统调用mknod( )建立。
它克服无名管道使用上的局限性，可让更多的进程也能利用管道进行通信。
因而其它进程可以知道它的存在，并能利用路径名来访问该文件。
对有名管道的访问方式与访问其他文件一样，需先用open( )打开。
2、无名管道一个临时文件。
利用pipe( )建立起来的无名文件（无路径名）。
只用该系统调用所返回的文件描述符来标识该文件，故只有调用pipe( )的进程及其子孙进程才能识别此文件描述符，才能利用该文件（管道）进行通信。
当这些进程不再使用此管道时，核心收回其索引结点。
二种管道的读写方式是相同的，本文只讲无名管道。
3、pipe文件的建立分配磁盘和内存索引结点、为读进程分配文件表项、为写进程分配文件表项、分配用户文件描述符4、读/写进程互斥内核为地址设置一个读指针和一个写指针，按先进先出顺序读、写。
为使读、写进程互斥地访问pipe文件，需使各进程互斥地访问pipe文件索引结点中的直接地址项。
实验3 进程通信
准备知识
掌握Socket通信的基本概念和工作原理； 掌握必要的网络知识，如TCP协议。
实验原理
Socket
Socket接口是TCP/IP网络的API，Socket接口定义了许多函数或例程 ，可以用来进行网络方面的程序设计与开发。Socket（套接字）是通 过标准的Unix文件描述符和其它程序通信的一个方法。Socket数据传 输是一种特殊的输入输出，Socket套接字也是一种文件描述符。 Socket也具有一个类似于打开文件的创建函数Socket( )，该函数返回 一个整型的Socket描述符，随后的建立连接、消息传输等操作都是对 该描述符进行操作的。每一个套接字都用一个半相关描述：{协议， 本地地址、本地端口}来表示；一个完整的套接字则用一个相关描述 ：{协议，本地地址、本地端口、远程地址、远程端口}。每一个套接 字都有一个本地的由操作系统分配的唯一的套接字号。
Socket的三种类型
(1)流式Socket（SOCK_STREAM） 流式套接字提供可靠的、面向连接的通信流；它使用TCP协议， 从而保证了数据传输的正确性和顺序性。 (2)数据报Socket（SOCK_DGRAM） 数据报套接字定义了一种无连接的服务，数据通过相互独立的报 文进行传输，是无序的，并且不保证可靠性、无差错。它使用数据报协 议UDP。 (3)原始Socket 原始套接字允许对底层协议如IP或ICMP直接访问，它功能强大 但使用较为不便，主要用于一些协议的开发。
实验3 进程通信
实验内容1 管道通信 实验内容12 Socket通信
管道通信
实 实 准 实 实
验 验 备 验 验
目 内 知 原 指
的 容 识 理 导
实验目的
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验三进程的管道通信一、实验目的（1）了解什么是管道（2）熟悉UNIX/LINUX支持的管道通信方式二、实验学时4学时三、实验内容编写程序实现进程的管道通信。
用系统调用pipe( )建立一管道，二个子进程P1和P2分别向管道各写一句话：Child 1 is sending a message!Child 2 is sending a message!父进程从管道中读出二个来自子进程的信息并显示（要求先接收P1，后P2）。
四、实验指导一、什么是管道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>2、read( )系统调用格式read(fd,buf,nbyte)功能：从fd所指示的文件中读出nbyte个字节的数据，并将它们送至由指针buf所指示的缓冲区中。
如该文件被加锁，等待，直到锁打开为止。
参数定义int read(fd,buf,nbyte);int fd;char *buf;unsigned nbyte;3、write( )系统调用格式read(fd,buf,nbyte)功能：把nbyte 个字节的数据，从buf所指向的缓冲区写到由fd所指向的文件中。
如文件加锁，暂停写入，直至开锁。
参数定义同read( )。
四、参考程序#include <unistd.h>#include <signal.h>#include <stdio.h>int pid1,pid2;main( ){int fd[2];char outpipe[100],inpipe[100];pipe(fd); /*创建一个管道*/while ((pid1=fork( ))= =-1);if(pid1= =0){lockf(fd[1],1,0);sprintf(outpipe,"child 1 process is sending message!");/*把串放入数组outpipe中*/write(fd[1],outpipe,50); /*向管道写长为50字节的串*/sleep(5); /*自我阻塞5秒*/lockf(fd[1],0,0);exit(0);}else{while((pid2=fork( ))= =-1);if(pid2= =0){ lockf(fd[1],1,0); /*互斥*/sprintf(outpipe,"child 2 process is sending message!");write(fd[1],outpipe,50);sleep(5);lockf(fd[1],0,0);exit(0);}else{ wait(0); /*同步*/read(fd[0],inpipe,50); /*从管道中读长为50字节的串*/printf("%s/n",inpipe);wait(0);read(fd[0],inpipe,50);printf("%s/n",inpipe);exit(0);}}}五、运行结果延迟5秒后显示child 1 process is sending message!再延迟5秒child 2 process is sending message!实验四进程间通信一、实验目的Linux系统的进程通信机构 (IPC) 允许在任意进程间大批量地交换数据。
本实验的目的是了解和熟悉Linux支持的消息通讯机制及信息量机制。
二、实验学时4学时三、实验内容利用msgget( )、msgsnd( )、msgrcv( )、msgctl( )等系统调用编写两个程序client.c和server.c，分别用于消息的发送和接收。
server建立一个key为75的消息队列，等待其它进程发来的消息。
当遇到类型为1的消息，则作为结束信号，取消该队列，并退出server。
server每接收到一个消息后显示一句“(server)received”。
client使用key为75的消息队列，先后发送类型从10到1的消息，然后退出。
最后一个消息，即是server端需要的结束信号。
client每发送一条消息后显示一句“(client)sent”。
四、实验要求阅读Linux系统的msg.c、sem.c和shm.c等源码文件，熟悉Linux的三种机制。
五、实验步骤利用msgget( )、msgsnd( )、msgrcv( )、msgctl( )等系统调用编写两个程序client.c和server.c，分别用于消息的发送和接收。
server建立一个key为75的消息队列，等待其它进程发来的消息。
当遇到类型为1的消息，则作为结束信号，取消该队列，并退出server。
server每接收到一个消息后显示一句“(server)received”。
client使用key为75的消息队列，先后发送类型从10到1的消息，然后退出。
最后一个消息，即是server端需要的结束信号。
client每发送一条消息后显示一句“(client)sent”。
server.c参考程序如下：#include <stdio.h>#include <stdlib.h>#include <sys/types.h>#include <sys/msg.h>#include <sys/ipc.h>#define MSGKEY 75struct msgform{long mtype;char mtext[1000];}msg;int msgqid;void server(){msgqid=msgget(MSGKEY,0777|IPC_CREAT); /*创建75#消息队列*/ do{msgrcv(msgqid,&msg,1030,0,0); /*接收消息*/printf("(server)received\n");}while(msg.mtype!=1);msgctl(msgqid,IPC_RMID,0); /*删除消息队列，归还资源*/ exit(0);}main(){server();}client.c参考程序如下：#include <stdio.h>#include <stdlib.h>#include <sys/types.h>#include <sys/msg.h>#include <sys/ipc.h>#define MSGKEY 75struct msgform{long mtype;char mtext[1000];}msg;int msgqid;void client(){int i;msgqid=msgget(MSGKEY,0777); /*打开75#消息队列*/for(i=10;i>=1;i--){msg.mtype=i;printf("(client)sent\n");msgsnd(msgqid,&msg,1024,0); /*发送消息*/}exit(0);}main(){client();}将上述两个程序分别编译为server和client，并按以下方式执行：./server &ipcs –q./clientClient和server分别发送和接收了10条消息。
观察运行结果，注意发送方发送消息和接收方接收消息的顺序。
涉及到的系统调用：1、msgget( )系统调用格式int msgget(key_t key, int msgflg);功能：获取与某个键关联的消息队列标识。
消息队列被建立的情况有两种：（1）如果键的值是IPC_PRIVATE。
（2）或者键的值不是IPC_PRIVATE，并且键所对应的消息队列不存在，同时标志中指定IPC_CREAT。
参数定义key：消息队列关联的键。
msgflg：消息队列的建立标志和存取权限。
返回说明：成功执行时，返回消息队列标识值。
失败返回-1，errno被设为以下的某个值：EACCES：指定的消息队列已存在，但调用进程没有权限访问它，而且不拥有CAP_IPC_OWNER权限EEXIST：key指定的消息队列已存在，而msgflg中同时指定IPC_CREAT和IPC_EXCL标志ENOENT：key指定的消息队列不存在同时msgflg中不指定IPC_CREAT标志ENOMEM：需要建立消息队列，但内存不足ENOSPC：需要建立消息队列，但已达到系统的限制该函数使用头文件如下：#include <sys/types.h>#include <sys/msg.h>#include <sys/ipc.h>2、msgsnd( )和msgrcv( )系统调用格式int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp, int msgflg);功能：在消息队列上进行收发消息。