实验四进程的管道通信实验

合集下载

实验一进程通信——管道和信号实验报告

进程管理实验报告【姓名】…【学号】…【实验题目】进程管理【实验目的】a.加深对进程概念的理解，明确进程和程序的区别；b.进一步认识并发执行的实质；c.分析进程争用资源的现象，学习解决进程互斥的方法；d．了解Unix系统中进程通信的基本原理【实验预备知识】学习UNIX中有关进程创建、控制和通信的部分。

【实验方法】利用Unix系统提供的内部函数创建进程并管理进程，从而实现进程控制、进程间通信和进程的管道通信。

【实验内容】（1）进程的创建编写程序，创建两个子进程。

当此程序运行时，系统中有一个父进程和两个子进程。

父进程在屏幕上显示“Parent”，子进程分别在屏幕上显示“Child1”和“Child2”。

（2）进程控制如果在程序中使用系统调用lockf()来给每一个进程加锁，可以实现进程之间的互斥，观察并分析出现的现象。

（3）进程间通信①编制一个程序，使其实现进程的软中断通信。

要求：使用系统调用fork()创建两个子进程，再用系统调用signal()让父进程捕捉键盘上来的中断信号（即DEL键）；当捕捉到中断信号后，父进程用系统调用kill()向两个进程发出信号，子进程捕捉到信号后分别输出下列信息后终止：Child Process 1 is Killed by Parent!Child Process 2 is Killed by Parent!父进程等待两个子进程终止后，输出如下信息后终止：Parent Process is killed!②在上面的程序中增加语句signal(SIGINT, SIG_IGN)和signal(SIGQUIT, SIG_IGN)，观察执行结果，并分析原因。

（4）进程的管道通信编制一段程序，实现进程的通信。

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

实验三_进程间通信 (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. 了解Linux系统中进程通信的基本原理。

三、实验内容1. 使用系统调用fork()创建两个子进程，父进程和子进程分别显示不同的字符。

2. 修改程序，使每个进程循环显示一句话。

3. 使用signal()捕捉键盘中断信号，并通过kill()向子进程发送信号，实现进程的终止。

4. 分析利用软中断通信实现进程同步的机理。

四、实验结果与分析1. 实验一：父进程和子进程分别显示不同的字符在实验一中，我们使用fork()创建了一个父进程和两个子进程。

在父进程中，我们打印了字符'a'，而在两个子进程中，我们分别打印了字符'b'和字符'c'。

实验结果显示，父进程和子进程的打印顺序是不确定的，这是因为进程的并发执行。

2. 实验二：每个进程循环显示一句话在实验二中，我们修改了程序，使每个进程循环显示一句话。

实验结果显示，父进程和子进程的打印顺序仍然是随机的。

这是因为并发执行的进程可能会同时占用CPU，导致打印顺序的不确定性。

3. 实验三：使用signal()捕捉键盘中断信号，并通过kill()向子进程发送信号在实验三中，我们使用signal()捕捉键盘中断信号（按c键），然后通过kill()向两个子进程发送信号，实现进程的终止。

实验结果显示，当按下c键时，两个子进程被终止，而父进程继续执行。

这表明signal()和kill()在进程控制方面具有重要作用。

4. 实验四：分析利用软中断通信实现进程同步的机理在实验四中，我们分析了利用软中断通信实现进程同步的机理。

通信管道实验报告(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. 掌握进程通信的常用方法，包括管道、消息队列、信号量等。

3. 通过编程实践，加深对进程通信机制的理解和应用。

二、实验环境操作系统：Linux开发环境：gcc三、实验内容1. 管道通信2. 消息队列通信3. 信号量通信四、实验步骤及分析1. 管道通信（1）实验步骤1）创建一个父进程和一个子进程；2）在父进程中创建一个管道，并将管道的读端和写端分别赋给父进程和子进程；3）在父进程中，通过管道的写端发送数据给子进程；4）在子进程中，通过管道的读端接收父进程发送的数据；5）关闭管道的读端和写端；6）结束进程。

（2）实验分析通过管道通信，实现了父进程和子进程之间的数据传递。

管道是半双工通信，数据只能单向流动。

在本实验中，父进程向子进程发送数据，子进程接收数据。

2. 消息队列通信（1）实验步骤1）创建一个消息队列；2）在父进程中，向消息队列中发送消息；3）在子进程中，从消息队列中接收消息；4）删除消息队列；5）结束进程。

（2）实验分析消息队列是一种进程间通信机制，允许不同进程之间传递消息。

消息队列的创建、发送、接收和删除等操作都是通过系统调用实现的。

在本实验中，父进程向消息队列发送消息，子进程从消息队列接收消息，实现了进程间的消息传递。

3. 信号量通信（1）实验步骤1）创建一个信号量；2）在父进程中，对信号量执行P操作，请求资源；3）在子进程中，对信号量执行V操作，释放资源；4）结束进程。

（2）实验分析信号量是一种用于实现进程同步的机制。

在进程通信中，信号量可以用来协调多个进程对共享资源的访问。

在本实验中，父进程和子进程通过信号量实现了对共享资源的同步访问。

五、实验结果1. 管道通信实验结果：父进程成功向子进程发送数据，子进程成功接收数据。

2. 消息队列通信实验结果：父进程成功向消息队列发送消息，子进程成功从消息队列接收消息。

3. 信号量通信实验结果：父进程成功获取资源，子进程成功释放资源。

进程通讯管理实验报告(3篇)

第1篇一、实验目的1. 理解进程通信的概念和原理；2. 掌握进程通信的常用机制和方法；3. 能够使用进程通信机制实现进程间的数据交换和同步；4. 增强对操作系统进程管理模块的理解。

二、实验环境1. 操作系统：Linux2. 编程语言：C3. 开发环境：GCC三、实验内容1. 进程间通信的管道机制2. 进程间通信的信号量机制3. 进程间通信的共享内存机制4. 进程间通信的消息队列机制四、实验步骤1. 管道机制（1）创建管道：使用pipe()函数创建管道，将管道文件描述符存储在两个变量中，分别用于读和写。

（2）创建进程：使用fork()函数创建子进程，实现父子进程间的通信。

（3）管道读写：在父进程中，使用read()函数读取子进程写入的数据；在子进程中，使用write()函数将数据写入管道。

（4）关闭管道：在管道读写结束后，关闭对应的管道文件描述符。

2. 信号量机制（1）创建信号量：使用sem_open()函数创建信号量，并初始化为1。

（2）获取信号量：使用sem_wait()函数获取信号量，实现进程同步。

（3）释放信号量：使用sem_post()函数释放信号量，实现进程同步。

（4）关闭信号量：使用sem_close()函数关闭信号量。

3. 共享内存机制（1）创建共享内存：使用mmap()函数创建共享内存区域，并初始化数据。

（2）映射共享内存：在父进程和子进程中，使用mmap()函数映射共享内存区域。

（3）读写共享内存：在父进程和子进程中，通过指针访问共享内存区域，实现数据交换。

（4）解除映射：在管道读写结束后，使用munmap()函数解除映射。

4. 消息队列机制（1）创建消息队列：使用msgget()函数创建消息队列，并初始化消息队列属性。

（2）发送消息：使用msgsnd()函数向消息队列发送消息。

（3）接收消息：使用msgrcv()函数从消息队列接收消息。

（4）删除消息队列：使用msgctl()函数删除消息队列。

进程的管道通信实验报告

进程的管道通信实验报告一、实验目的本实验旨在通过实际操作，深入理解进程间通信（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．实验目的：（1）加深对进程概念的理解，明确进程和程序的区别；（2）进一步认识并发执行的实质；（3）分析进程争用资源的现象，学习解决进程互斥的方法；（4）了解Linux系统中进程通信的基本原理。

2．实验预备内容（1）阅读Linux的源码文件，加深对进程管理概念的理解；（2）阅读Linux的fork()源码文件，分析进程的创建过程。

3．实验内容（1）进程的创建：编写一段程序，使用系统调用fork() 创建两个子进程。

当此程序运行时，在系统中有一个父进程和两个子进程活动。

让每一个进程在屏幕上显示一个字符：父进程显示字符“a”，子进程分别显示字符“b”和“c”。

试观察记录屏幕上的显示结果，并分析原因。

源代码:#include <>#include <>#include <sys/>#include <>main(){int p1,p2;p1=fork();ockf()函数是将文件区域用作信号量（监视锁），或控制对锁定进程的访问（强制模式记录锁定）。

试图访问已锁定资源的其他进程将返回错误或进入休态，直到资源解除锁定为止。

而上面三个进程，不存在要同时进入同一组共享变量的临界区域的现象，因此输出和原来相同。

（3）a) 编写一段程序，使其实现进程的软中断通信。

要求：使用系统调用fork() 创建两个子进程，再用系统调用signal() 让父进程捕捉键盘上来的中断信号（即按DEL键）；当捕捉到中断信号后，父进程用系统调用Kill() 向两个子进程发出信号，子进程捕捉到信号后分别输出下列信息后终止：Child Process 1 is killed by Parent!Child Process 2 is killed by Parent!父进程等待两个子进程终止后，输出如下的信息后终止：Parent Process is killed!源代码：#include <>#include <>#include <sys/>#include <>#include<>int sign;void waiting(){while(sign!=0);}void stop(){sign=0;}main(){int p1,p2;p1 = fork();if ( p1 == 0 )子进程1收到软中断信号16时，调用函数stop()解除“waiting”,继续往下执行；等它打印完了child process 1 is killed by parent,就退出；对于子进程2来说也是如此。

进程的管道通信实验总结

进程的管道通信实验是一个非常有用的实验，它允许两个进程之间进行数据交换。

这个实验主要涉及到了管道、管道缓冲区以及进程之间的通信机制。

以下是对这个实验的总结：
1. 管道的概念和作用：
管道是一种用于进程间通信的机制，它允许两个进程之间进行数据交换。

在管道通信实验中，我们创建了一个管道，并使用它来在两个进程之间传递数据。

管道的作用是连接两个进程，使得它们可以相互发送和接收数据。

2. 管道缓冲区：
管道缓冲区是管道中的一个重要概念。

当一个进程向管道写入数据时，数据会被写入缓冲区中，等待另一个进程读取。

当缓冲区中的数据被读取后，缓冲区中的数据会被移除，为新的数据腾出空间。

3. 进程间的通信：
在管道通信实验中，我们创建了两个进程，并使用管道来在它们之间进行通信。

一个进程向管道写入数据，另一个进程从管道读取数据。

通过这种方式，两个进程可以相互发送和接收数据。

4. 实验中的问题和解决方案：
在实验中，我们遇到了一些问题，如管道中的数据读写错误、进程间的通信问题等。

为了解决这些问题，我们采取了一些措施，如检查数据的读写是否正确、确保进程间的通信畅通等。

5. 实验的意义和收获：
通过这个实验，我们深入了解了进程间通信的概念和机制，并掌握了管道通信的基本原理和方法。

此外，我们还学会了如何解决实验中遇到的问题，提高了我们的编程能力和解决问题的能力。

总之，进程的管道通信实验是一个非常有意义的实验，它让我们深入了解了进程间通信的原理和方法。

通过这个实验，我们不仅掌握了相关的知识和技能，还提高了我们的编程能力和解决问题的能力。

实验4 进程的管道通信

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

2）学习进程创建的过程，进一步认识进程并发执行的实质。

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

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

5）掌握Linux系统中进程间通过管道通信的具体实现。

二、实验内容及要求1）使用系统调用函数pipe()建立一条管道，系统调用fork()分别创建两个子进程，它们分别向管道写一句话，如：Child process1 is sending a message!Child process2 is sending a message!2）父进程分别从管道读出来自两个子进程的信息，显示在屏幕上。

3）这是一个设计型实验，要求自行、独立编制程序。

4）两个子进程要并发执行。

5）实现管道的互斥使用。

当一个子进程正在对管道进行写操作时，另一个欲写入管道的子进程必须等待。

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

6）实现父子进程的同步，当父进程试图从一空管道中读取数据时，便进入等待状态，直到子进程将数据写入管道返回后，才将其唤醒。

三、程序流程图父进程子进程P1和P2：四、源代码及注释#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,pid1,pid2,fd[2];char str1[100],str2[100];pipe(fd);//创建管道while((pid1=fork())==-1);//创建子进程P1失败循环if(pid1==0)子进程P1{lockf(fd[1],1,0);//锁住管道写端sprintf(str1,"child process pid1 is sending messages!\n");printf("child process pid1!\n");write(fd[1],str1,100);//写入管道printf("pid1=%d\n",pid1);sleep(5);//睡眠等待lockf(fd[1],0,0);//解锁exit(0);//结束子进程P1}else{while((pid2=fork())==-1);//创建子进程P2失败循环if(pid2==0)//子进程P2{lockf(fd[1],1,0);锁住管道写端sprintf(str1,"child process pid2 is sending messages!\n");printf("child process pid2!\n");write(fd[1],str1,100);//写入管道printf("pid2=%d\n",pid2);sleep(5);//睡眠等待lockf(fd[1],0,0);//解锁exit(0);//结束子进程P2}wait(0);//子进程P1返回子进程if(r=read(fd[0],str2,100)==-1)//读取失败printf("can't read pipe\n");else printf("%s\n",str2);wait(0);//子进程P2返回if(r=read(fd[0],str2,100)==-1)printf("can't read pipe\n");else printf("%s\n",str2);exit(0);}return 0;}五、运行结果及说明六、课后习题1）指出父进程与两个子进程并发执行的顺序，并说明原因。

实验四进程通信实验

实验四：进程通信实验实验学时：3学时一、实验目的1、熟悉操作系统进程通信原理2、设计程序，实现共享内存、管道通信、消息通信二、实验基本原理1、进程间通信的几种方法简介（1）消息队列：消息队列是消息的链接表，包括Posix消息队列systemV消息队列。

有足够权限的进程可以向队列中添加消息，被赋予读权限的进程则可以读走队列中的消息。

（2）共享内存：使得多个进程可以访问同一块内存空间，是最快的可用IPC形式。

是针对其他通信机制运行效率较低而设计的。

往往与其它通信机制，如信号量结合使用，来达到进程间的同步及互斥。

（3）无名管道（Pipe）及有名管道（named pipe）：有名管道克服了管道没有名字的限制，因此，除具有管道所具有的功能外，它还允许无亲缘关系进程间的通信；无名管道可用于有亲缘关系的进程之间彼此的通信，进行通信时候必须有一定的机制保证对管道写和读的互斥：即在读是要关闭写的端口，而在写的时候也要保证读的一端是关闭的。

2、进程通信函数（1）消息队列有关系统调用函数a.创建消息队列使用msgget()函数：#include <sys/types.h>#include <sys/ipc.h>#include <sys/msg.h>int msgget(key_t key, int flag) ;该函数成功调用返回消息队列标识符。

其中的key是关键字，可以由ftok()函数得到：key=ftok(“.”,’a’);其中”.”可以是任何目录，’a’是任意字符，即所有群组标识。

flag是标识，IPC_CREAT位表示创建，一般由服务器程序创建消息队列时使用。

如果是客户程序，必须打开现存的消息队列，必须不使用IPC_CREAT。

发送和接收的消息都必须使用一个类似msgbuf的结构表示，msgbuf结构定义如下：struct msgbuf{long mtype;char mtext[1];}上面的定义，消息内容只有一个字节，是不实用的，一般我们需要重新定义一个结构：struct amsgbuf{long mtype;char mtext[200];}其中的mtype都是消息类型。

进程之间的通信实验

实验：进程之间的通信管道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中的两个命令的组合。

管道通信实验

操作系统实验报告
院系：计算机系
姓名:李
学号:10
专业:科学技术
年级:10级
实验题目:管道通信实验
一、实验目的（包括：实验内容、实验原理、实验目标）
1、了解管道的基本概念
2、掌握Linux支持的管道通信方式
二、实验设计（包括:设计思路、数据结构、程序流程图、关键代码说明）
本实验利用管道通信机制，实现输入字符串的自动分流操作。一共涉及3个管道，4个进程。P1：从键盘接受输入字符串，写入管道pipe1
{
close(d1[1]); //p1必须关闭写
read(d1[0],buff,sizeof(buff)); //p2从pipe1中读信息
if(strlen(buff)%2==1) //判断字符串长度，若为奇数
{
j=fork(); //创建子进程P3
if(j) //P3执行
}
}
三、实验结果（包括:运行结果、结果分析）
教师评语
成绩:教室签名:年月日
Please input a string: apple
P2 finishes writing to pipe2.
P3 pipe2 odd length string:apple
Please input a string: pear
P2 finishes writing to pipe3.
P4 pipe3 even length string:pear
P2：从pipe1接受字符串，若字符串的长度为偶数，则将其写入管道pipe2，负责写入管道pipe3.P3：从pipe2读出字符串，并显示pipe2：Even length string：偶长度字符串。P4：从pipe3读出字符串，并显示pipe3：Old length string：奇长度字符串。输入exit程序退出，示意图如下图1.1

操作系统实验报告进程的管道及消息通信

对观察到的内容做详细记录分析, 并写出实验报告。

对观察到的内容做详细记录分析，并写出实验报告。

四、实验过程与分析1.使用无名管道pipe(), 进行父子进程之间的通信。

编写的程序如下:运行结果如下:结果分析:父进程首先被调用时, 运行结果为：之后父进程阻塞等待子进程终止, 当系统调度子进程运行时, 输出如下的信息:之后父进程被唤醒, 调度运行, 输出如下结果后程序退出。

对于以上的结果: 首先父进程使用pipe（chan1）系统调用打开一个无名管道, 之后创建一个子进程。

子进程复制父进程的打开文件表。

为了正确通信, 父进程关闭读通道close（chan1[0]）, 子进程关闭写通道close（chan1[1]）。

父进程向管道写, 子进程从管道读。

完成一次通信之后, 父进程分别关闭自己的写/读通信, 管道文件消失。

2.以命名行为参数的管道文件的示例。

(假设有一个可执行程序chcase, 从标准输入设备读字符, 将小写字母转化成大写字母并输出。

主程序使用popen创建管道, 实现蒋某文本文件中的字幕转化成大写字母, 其中的文本文件名作为参数传进来。

)编写的程序如下:运行结果是:结果分析: 通过程序运行结果可知, 先打开文本文件, 如果文本打开失败, 则执行exit（1）, 退出程序, 如果文本通过函数开成功, 则popen创建一个可写管道, 将命令行chcase的输入与管道的输入连接起来, 然后向管道输入数据, 此时命令行就可以通过管道接受文本文件的数据了,在从文件中读出数据时, 独处的内容放在line[]数组中,fpin表示从刚打开的文件里读出。

之后要编写字母大小写转化函数, 来实现小写字母转化成大写字母。

3.创建有名管道。

编写的程序如下:运行结果是:前台运行结果:后台运行结果:结果分析: 此程序是把管道和命令联系起来, read( )的系统调用格式是read(fd,buf,n), 参数定义是int read(fd,buf,n); int fd; char *buf; unsigned n;它的功能是从fd所指示的文件中读出n个字节的数据, 并将它们送至由指针buf所指示的缓冲区中。

管道通信实验报告

实验5 管道通信实验目的1、了解什么是管道2、掌握父子进程使用管道通信的方法实验内容1、父子进程基于管道的简单通信。

#include "unistd.h"#include "stdio.h"#include "string.h"main(){ int fd[2],pid,n;char buffer[256],dat[20]="hello world\n";pipe(fd);pid=fork();if(pid==0){ close(fd[1]);n=read(fd[0],buffer,256);printf("child %d read %d bytes:%s",getpid(),n,buffer);}else{close(fd[0]);write(fd[1],dat,strlen(dat));printf("parent write%d byge: %s\n",strlen(dat),dat);}exit(0);}运行程序，观察程序执行的结果实验结果：2、同一个进程树的兄弟进程通信#include"unistd.h"#include"stdio.h"#include"string.h"main(){int fd[2],pid,pir,n,i;char b[20]="dsf",dat[20]="hello!";pipe(fd);pid=fork();if(pid>0){pir=fork();if(pir==0) //第二个子进程从管道里读，当从读出的首字母为’a’结束while (b[0]!='a'){n=read(fd[0],b,20);printf("child2 :%s\n",b);sleep(1);}else{wait(0);wait(0);printf("parent is kill!\n");}}else { //第一个子进程向管道里写内容，当从键盘接收的首字母为’a’结束while(dat[0]!='a'){scanf("%s",dat);write(fd[1],dat,strlen(dat));sleep(1);}printf("child1 is writing\n");}}实验结果：。

管道通信操作系统实验报告

1、使用fork()创建两个子进程pid1和pid2
2、使用pipe()创建一个无名管道fd，fd[0]为读出端，fd[1]为写入端
3、定义两个缓冲区OutPipe[100]和InPipe[100]
4、使用read()和write()进行管道的读和写，利用lockf()实现对管道的只读或只写
5、使用sleep()来调整锁定的时间流程：
开始
目」建科
Mpidl
id1创建成
锁定管道写入端
将信息"child ph
Sending rriessage
DC&SS1is
卩输入0血应
将加滋信息写入fi叩I
L
解除写兀端锁定
是
子讲程1等待父讲程从伺间读詹虐到imj取
创建孑进程卩皿
Fid2创連成I
否
锁定管道写入端
将信息"ctiild process2is SEritJirg|71已55日駅|'輸入朝加
#i nclude <stdio.h>
2、从管道读数据：read()
系统调用格式：read(fd,buf, nbyte)
功能：从fd所指示的文件中读出nbyte个字节的数据，并将它们送至由指针buf所指示的缓冲区中。如该文件被加锁，等待，直到锁打开为止。
参数定义：int read(fd,buf, nbyte);
计算机与信息技术学院综合性、设计性实验报告
专业：计算机科学与技术年级/班级：08级计科一班2010—2011学年第一学期
课程名称
计算机操作系统
指导教师
本组成员学号姓名
实验地点
计算机学院过街天桥机房C区
实验时间
2010.11.7

实验四、进程通信(二) ——消息通信

操作系统实验报告实验四、进程通信（二）——消息通信一、实验目的1）加深对管道通信的了解2）掌握利用管道进行通信的程序设计3）了解共享内存通信的程序设计方法4）了解和熟悉Linux支持的共享存储区机制二、实验内容任务：（1）每个同学登陆两个窗口，先在一个窗口中运行程序1（或者只登陆一个窗口，先在该窗口中以后台方式运行程序1），用ipcs命令查看系统中消息队列的情况，然后在另一个窗口中运行程序2，观察程序的运行结果并分析。

运行结束后可以用ctrl+c结束程序1的运行，再次用ipcs命令观察系统中消息队列的情况。

（2）使用系统调用msgget()，msgsnd()，msgrev()及msgctl()编制一长度为1K的消息的发送和接收程序。

①为了便于操作和观察结果，用一个程序作为“引子”，先后fork()两个子进程，SERVER和CLIENT，进行通信。

②SERVER端建立一个Key为学号末3位的消息队列，等待其他进程发来的消息。

当遇到类型为1的消息，则作为结束信号，取消该队列，并退出SERVER。

SERVER每接收到一个消息后显示一句“(server)received”。

③CLIENT端使用key为学号末3位的消息队列，先后发送类型从10到1的消息，然后退出。

最后的一个消息，即是SERVER端需要的结束信号。

CLIENT 每发送一条消息后显示一句“(client)sent”。

④父进程在SERVER和CLIENT均退出后结束。

三、代码及运行结果分析（1）每个同学登陆两个窗口，先在一个窗口中运行程序1（或者只登陆一个窗口，先在该窗口中以后台方式运行程序1），用ipcs命令查看系统中消息队列的情况，然后在另一个窗口中运行程序2，观察程序的运行结果并分析。

运行结束后可以用ctrl+c结束程序1的运行，再次用ipcs命令观察系统中消息队列的情况先在一个窗口中运行程序1程序1实验代码：#include <sys/types.h>#include <sys/ipc.h>#include <sys/msg.h>#define MSGKEY 208 /*在实际实验过程中，为了避免每个同学建立的消息队列关键字一样而相互干扰，关键字请用学号末3位*/struct msgform{long mtype;char mtext [256];}msg;int msgqid;main (){int i ,pid, *pint;extern cleanup();for (i=0;i<20;i++)/*软中断处理*/signal (i,cleanup);msgqid = msgget (MSGKEY,0777|IPC_CREAT);/*建立与顾客进程相同的消息队列*/ for (;;){msgrcv (msgqid ,&msg,256,1,0);/*接收来自顾客进程的消息*/pint=(int * ) msg. mtext;pid = * pint;printf ("server:receive from pid %d\n",pid);msg.mtype=pid;*pint=getpid();msgsnd (msgqid,&msg ,sizeof (int) ,0) ;/*发送应答消息*/}}cleanup(){msgctl (msgqid ,IPC_RMID,0);exit();}运行结果：ipcs命令查看在另一个窗口中运行程序2程序2实验代码：#include <sys/types.h>#include <sys/ipc.h>#include <sys/msg.h>#define MSGKEY 208 /*在实际实验过程中，为了避免每个同学建立的消息队列关键字一样而相互干扰，关键字请用学号末3位*/struct msgform{long mtype;char mtext [256];};main(){struct msgform msg;int msgqid,pid, *pint;msgqid=msgget(MSGKEY,0777);/*建立消息队列*/pid=getpid();pint=(int *)msg.mtext;*pint=pid;msg.mtype=1;/*指定消息类型*/msgsnd(msgqid,&msg,sizeof(int),0);/*往msgqid发送消息msg*/msgrcv(msgqid,&msg,256,pid,0);/*接收来自服务进程的消息*/printf("client : receive from pid%d\n",*pint);}运行结果：再次用ipcs命令观察系统中消息队列的情况分析：调用pipe(fd);创建一个管道后，接着调用fork()函数产生两个进程，首先开始执行子进程，关闭管道出口，通过管道入口向管道中写入内容。

第四次实验进程的管道及消息通信

客户进程用关键字SVKEY和标准msgget（）得到消息队列标识符msqid，之后用msqid调用msgsnd()将自己的pid发送到消息队列（SVKEY）中，表示其所请求的服务，然后调用msgrcv()等待服务结果消息的到来。
服务者进程接收到请求服务的消息后进行服务工作，完成服务后客户进程发送回一条消息，消息的类型为客户的标识pid，消息正文是服务者进程自己的标识pid。
buf[0]='\0';
}
}
close(fd);
}
二．消息缓冲机制
消息缓冲是unix系统进程之间进行大量数据交换的机制之一。消息缓冲是基于消息队列的，发送进程将消息挂入接收进程的消息队列，接收进程从消息队列中接收消息。消息是指具有类型和数量的一个数据。消息分为私有和公有的，如果消息是私有的，只能被创建消息队列的进程和其子进程访问；如果是公有的，可以被系统中知道消息队列名的所有进程访问。消息可以安类型访问，因此，不必按序访问。
}
main()
{
int msqid;
struct msgform msg;
int i,pid,* pint;
msqid = msgget(SVKEY,0777 | IPC_CREAT);//创建消息队列
for(;;)
{
msgrcv(msqid,&msg,256,REQ,0);//接受客户发送的消息
班级
2009级计本
学号
200981010142
一、实验目的
熟悉UNIX和linux操作系统进程通信的系统调用。
理解和掌握UNIX和LINUX进程通信系统的调用的功能，给出了进程通讯实现机制中的使用的系统调用命令的格式和如何利用系统调用命令进行进程通信编程，通过学习，提高对进程之间可通过系统的编程能力。

进程通信实验报告

进程通信实验报告进程通信实验报告概述进程通信是操作系统中非常重要的一个概念，它允许不同的进程之间进行数据的交换和共享。

在本次实验中，我们通过使用不同的进程通信机制，如管道、消息队列和共享内存，来实现进程之间的数据传输和通信。

本报告将详细介绍实验的背景、实验过程、结果分析以及对实验的总结。

实验背景进程通信是操作系统中的一个核心概念，它允许多个进程之间进行数据的交换和共享。

在现代操作系统中，进程通信是实现并发和协作的重要手段。

了解不同的进程通信机制以及它们的优缺点对于深入理解操作系统的原理和实现至关重要。

实验过程在本次实验中，我们使用了三种不同的进程通信机制：管道、消息队列和共享内存。

首先，我们创建了两个进程，一个作为发送方，一个作为接收方。

然后，我们分别使用了管道、消息队列和共享内存来实现进程之间的数据传输和通信。

管道是一种最简单的进程通信机制，它可以在父进程和子进程之间进行单向的通信。

我们通过创建一个管道，并将其连接到父进程和子进程的标准输入和标准输出，实现了父子进程之间的数据传输。

消息队列是一种更为灵活的进程通信机制，它可以实现多个进程之间的双向通信。

我们使用了系统提供的消息队列函数，创建了一个消息队列，并在发送方将消息发送到队列中，接收方则从队列中接收消息。

通过消息队列，我们实现了进程之间的异步通信。

共享内存是一种高效的进程通信机制，它允许多个进程共享同一块内存空间。

我们使用了共享内存函数，创建了一个共享内存区域，并将其映射到两个进程的虚拟地址空间中。

通过共享内存，我们实现了进程之间的数据共享和同步。

结果分析通过实验，我们发现不同的进程通信机制各有优缺点。

管道是最简单的一种机制，但只能实现单向通信，且只能用于具有亲缘关系的进程。

消息队列可以实现多个进程之间的双向通信，但消息的顺序可能会被打乱。

共享内存是最高效的一种机制，但需要额外的同步机制来保证数据的一致性。

总结进程通信是操作系统中非常重要的一个概念，它允许不同的进程之间进行数据的交换和共享。

进程和进程管道通信实验

close(pipe4[1]);
close(pipe4[0]);
close(pipe1[1]);
close(pipe3[0]);
pause();//暂停，等待进程3唤醒
//每次从管道1的0端读取x
//进行函数运算后，将函数运算结果fx通过管道1的1端写入
do{
read(pipe1[0],&x,sizeof(int));
CPU英特尔酷睿i7四核2.53GHz
主板LENOVO -英特尔HM65 (Cougar Point) [B3]
内存Ramaxel Technology 4G DDR3 SDRAM 1333 MHz双通道
显卡ATI Mobility Radeon HD 6500M
主硬盘希捷500GB
声卡High Definition Audio Controller [B3]
close(pipe2[1]);
close(pipe4[0]);
close(pipe1[1]);
close(pipe3[0]);
//子进程执行结束
printf("child%dread.\n",getpid());
exit(EXIT_SUCCESS);
}
}
}
//父进程执行结束
returnEXIT_SUCCESS;
网卡英特尔WiFi Link 1000 BGN
实验思路
本实验的设置首先要参考到实验一中的协同进程运行。首先创建3个子进程，分别处理f(x)、f(y)、f(x,y)。由于f(x)和f(x,y)、f(y)和f(x,y)之间需要交换数据，参考实验手册可以发现：管道是半双工的，所以需要4个管道。再加上管道默认的同步方式是同步读写，所以可以建立低些的循环，进行运算。