实验5 进程间通信实验

合集下载

进程间通信实验报告

进程间通信实验报告

软件学院计算机课程实验报告册课程名称计算机操作系统实验学期 2011 年至 2012 年第 2 学期学生所在院(系)软件学院年级 11软件专业班级软工(1)班学生姓名朱水云学号 **********指导教师陈自刚实验最终成绩软件学院实验室制2012 年 4 月实验报告( 二 ) 实验名称:进程间通信实验时间:2012年4月18号实验性质应用性设计性综合性5,观察运行结果,并思考6,退出中断并写出实验报告调试过程:根据编译提示的错误进行修改四、实验结果:1消息的发送和接受运行结果:2.共享存储区的创建、附接和段接运行结果:五、疑难与小结:1.消息的创建,发送和接收小结:从理想的结果来说,应当是每当Client发送一个消息后,server 接收该消息,Client再发送下一条。

也就是说“(Client)sent”和“(server)received”的字样应该在屏幕上交替出现。

实际的结果大多是,先由 Client 发送两条消息,然后Server接收一条消息。

此后Client Server交替发送和接收消息.最后一次接收两条消息. Client 和Server 分别发送和接收了10条消息,与预期设想一致message的传送和控制并不保证完全同步,当一个程序不再激活状态的时候,它完全可能继续睡眠,造成上面现象,在多次send message 后才 receive message.这一点有助于理解消息转送的实现机理.2.共享存储区的创建、附接和段接运行的结果和预想的完全一样。

但在运行的过程中,发现每当client 发送一次数据后,server要等大约0.1秒才有响应。

同样,之后client又需要等待大约0.1秒才发送下一个数据。

出现上述的应答延迟的现象是程序设计的问题。

当client端发送了数据后,并没有任何措施通知server端数据已经发出,需要由client的查询才能感知。

此时,client端并没有放弃系统的控制权,仍然占用CPU的时间片。

进程间通信

进程间通信

《操作系统》实验报告年级、专业、班级 姓名进程间通信实验题目实验时间 2014.11.21 实验地点 A主0410实验成绩 实验性质 □验证性 □设计性 □综合性 教师评价:□算法/实验过程正确; □源程序/实验内容提交 □程序结构/实验步骤合理;□实验结果正确; □语法、语义正确; □报告规范;其他:评价教师签名:一、实验目的1. 了解管道通信的特点,掌握管道通信的使用方法。

2. 了解消息队列通信机制及原理,掌握消息队列相关系统调用的使用方法及功能。

3. 了解Linux系统共享存储区的原理及使用方法。

二、实验项目内容1. 管道通信(1)父进程创建管道和两个子进程p1和p2。

(2)子进程p1打开给定文件(如果没有,则创建文件),并向文件中写数据,写完关闭文件,然后向管道写入一条消息“ok",目的是通知进程p2可以读取文件内容了。

(3)子进程p2通过管道读取消息,如果消息是“ok”,则打开文件,读取文件内容,并将其输出到屏幕上,关闭文件.2. 消息队列(1)父进程创建消息队列和两个子进程p1和p2。

(2)子进程p1打开给定文件(如果没有,则创建文件),并向文件中写数据,写完关闭文件,然后向消息队列写入一条消息“1",目的是通知进程p2可以读取文件内容了。

(3)子进程p2从消息队列读取消息,如果收到消息,则打开文件,读取文件内容,并将其输出道屏幕上,关闭文件。

3. 共享存储(1)由父进程建立一块共享存储区,并创建两个子进程p1,p2,父进程负责查询存储区状态,以及删除该存储区。

(2)子进程p1链接到该共享存储区,然后向存储区写入数据,写完断开链接。

(3)子进程p2链接到该共享存储区,从存储区读数据,然后断开链接。

注意:为了便于各进程对存储区访问的同步,这里使用信号量方法。

三、实验过程或算法1. 管道通信#include<unistd.h>#include<stdio.h>#include<string.h>#include<stdlib.h>int main() {int pipefd[2];pid_t pid;char buf[100];int n;为0memset(buf, 0, sizeof(buf));//clear bufif(pipe(pipefd) < 0) {perror("pipe");exit(0);}pid = fork();if(pid == 0) { //child process 1close(pipefd[0]);//close read fdchar *msg="Hello,I am a Pipe user.";write(pipefd[1], msg, 50);}else if(pid > 0) {pid = fork();if(pid == 0) { //child process 2close(pipefd[1]);//close write fdread(pipefd[0], buf, sizeof(buf));fprintf(stdout, "read from pipe is:%s\n", buf);}else if(pid > 0) exit(0);}}2.消息队列//发送消息,msqid是队列id,msg是要发送的消息void sendmsg(int msqid,mymesg msg){printf("msqid:%d,msg:%s\n",msqid,msg.mtext);if((msgsnd(msqid, &msg, sizeof(msg.mtext), IPC_NOWAIT)) != 0){//消息发送函数printf("pid_1:send msg error!\n");}else{printf("pid_1:send msg: %s succeed!\n", msg.mtext);}}//接收消息,msqid是队列idint rcvmsg(int msqid){mymesg msg={0};AIT);int msg_len = msgrcv(msqid, &msg, sizeof(msg.mtext), 0, IPC_NOW //接收消息函数if(msg_len < 0){printf("pid_2:receive msg error!\n");return 0;}printf("pid_2:recv msg: %s\n", msg.mtext);return 1;}3.共享存储创建共享存储区 shmid = shmget(IPC_PRIV A TE, SIZE, IPC_CREAT|0600 ) ;//{if ( shmid < 0 )perror("get shm ipc_id error") ;return -1 ;}pid = fork() ;子进程p1if ( pid == 0 ){ //printf("I'm child1 process,my pid is %d.\n",getpid());P操作sem_p(sem_id); //链接到存储区 shmaddr = (char *)shmat( shmid, NULL, 0 ) ;//if ( (int)shmaddr == -1 ){perror("shmat addr error") ;return -1 ;}向存储区写数据strcpy( shmaddr, "Hi,This is share memory!\n") ;//shmdt( shmaddr ) ;//断开链接V操作sem_v(sem_id); //父进程} else if ( pid > 0) {//printf("I'm father process,my pid is %d.\n",getpid());pid = fork();sleep(1);子进程2创建if(pid==0){//printf("I'm child2 process,my pid is %d.\n",getpid());P操作sem_p(sem_id); //读取存储区状态到buf中flag = shmctl( shmid, IPC_STAT, &buf) ;//{if ( flag == -1 )perror("shmctl shm error") ;return -1 ;}printf("shm_segsz =%d bytes\n", buf.shm_segsz ) ;printf("parent pid=%d, shm_cpid = %d \n", getppid(), buf.shm_cpid ) ;printf("chlid pid=%d, shm_lpid = %d \n",pid, buf.shm_lpid ) ;printf("shm_segsz =%d \n", buf.shm_perm.mode );shmaddr = (char *) shmat(shmid, NULL, 0 ) ;链接到存储区,读取其中数据if ( (int)shmaddr == -1 ){//perror("shmat addr error") ;return -1 ;}//打印数据到屏幕printf("%s", shmaddr) ;V操作sem_v(sem_id); //断开链接shmdt( shmaddr) ;//}else{perror("fork error.") ;shmctl(shmid, IPC_RMID, NULL) ;}删除该存储区shmctl(shmid, IPC_RMID, NULL) ;//return 0 ;}四、实验结果及分析和(或)源程序调试过程(包含程序使用方法、程序运行截图),实验过程中遇到的问题分析与心得体会。

实验五 进程通信

实验五  进程通信

(2)读管道 在管道创建后,希望从管道中读取数据的进程使 用读文件描述符fd[0]作为参数,调用read( )系统调用。 #include <unistd.h> ssize_t read(int fd,void *buf,size_t nbytes); 返回:读到的字节数,若已到文件尾为0,若出错 为-1。 (3)写管道 向管道中写入数据的进程使用写文件描述符fd[1] 作为参数,调用write( )系统调用。 #include <unistd.h> ssize_t write(int fd,const void *buf,size_t nbytes); 返回:若成功为已写的字节数,若出错为-1。
2. 管道是UNIX系统中最早为两个进程之间提 供的一种通信机制。管道是一种单向的、先入 先出的、无结构的、大小固定的通信通道。写 进程在管道的一端写入数据,读进程从管道的 另一端读出数据。如果两个或多个进程同时对 一个进程进行读写,那么这些进程必须使用锁 机制或者信号量机制对其进行同步。 管道分为无名管道和有名管道。无名管道 没有名字,所以只能提供给进程家族中的父子 进程间通信使用,而有名管道则用于没有家族 关系的任意两个进程之间的通信。
wait(0); read(fd[0], inpipe, 50); printf(“%s\n”, inpipe); wait(0); read(fd[0], inpipe, 50); printf(“%s\n”, inpipe); exit(0);
}
} }Байду номын сангаас四. 试验总结
1. 写出试验报告。 2. 为程序添加注释。 3. 分析信号通信和管道通信各自的特点。

2. 编写一段程序,实现进程的管道通信。 使用系统调用pipe( )建立一条管道,创建两个子进程 P1和P2。 让P1和P2分别向管道各写一句话: Child 1 is sending a message! Child 2 is sending a message! 父进程则从管道中读出来自于两个子进程的信息, 显示在屏幕上。要求:父进程先接受子进程P1发来的 消息,然后再接受子进程P2发来的消息。 参考程序如下:

实验五:进程间通信

实验五:进程间通信

实验五:进程间通信实验五:进程间通信●实验目的:学会进程间通信方式:无名管道,有名管道,信号,共享内存●实验要求:(一)在父进程中创建一无名管道,并创建子进程来读该管道,父进程来写该管道(二)在进程中为SIGBUS注册处理函数,并向该进程发送SIGBUS信号(三)创建一共享内存,实现放进程间通信●实验器材:软件:安装了Linux的vmware虚拟机硬件:PC机一台●实验步骤:(一)无名管道的使用1、编写实验代码pipe_rw.c#include#include#include#include#include#includeint main(){int pipe_fd[2];pid_t pid;char buf_r[100];char* p_wbuf;int r_num;memset(buf_r,0,sizeof(buf_r));/*创建管道*/if(pipe(pipe_fd)<0){printf("pipe create error\n");return -1;}/*创建子进程*/if((pid=fork())==0) //子进程执行代码{//1、子进程先关闭了管道的写端//2、让父进程先运行,这样父进程先写子进程才有内容读//3、读取管道的读端,并输出数据//4、关闭管道的读端,并退出}else if(pid>0) //父进程执行代码{//1、父进程先关闭了管道的读端//2、向管道写入字符串数据//3、关闭写端,并等待子进程结束后退出}return 0;}2、编译应用程序pipe_rw.c3、运行应用程序子进程先睡两秒让父进程先运行,父进程分两次写入“hello”和“pipe”,然后阻塞等待子进程退出,子进程醒来后读出管道里的内容并打印到屏幕上再退出,父进程捕获到子进程退出后也退出4、由于fork函数让子进程完整地拷贝了父进程的整个地址空间,所以父子进程都有管道的读端和写端。

操作系统惠普测试171+实验5-进程的管道通信实验

操作系统惠普测试171+实验5-进程的管道通信实验

操作系统原理A实验报告学生姓名:陶浩学号:22 班级:惠普测试171 实验5 进程的管道通信实验实验指导教师:葛艳5 进程的管道通信实验一、实验目的1. 了解管道通信机制的基本原理。

2.理解无名管道的通信原理及使用方法。

3.掌握父子进程使用无名管道通信的方法。

二、实验内容1. 编译运行,把程序运行结果截图,分析程序的执行过程。

2. 编译运行,把程序运行结果截图,分析程序的执行过程。

3.编写程序实现多个进程基于无名管道进行通信。

用系统调用pipe()建立一无名管道,两个子进程P1和P2分别向管道写入一句话(包含自己的姓名)。

父进程等待子进程结束后,从无名管道中读出两个来自子进程的信息并显示,子进程发送先后顺序没有要求。

三、实验步骤及运行结果分析1. 编译运行,把程序运行结果截图,分析程序的执行过程。

分析:pipe(fd)创建一个无名管道,fork()用于创建一个子进程,基于管道的通信一般都是先创建管道后创建进程。

程序运行到if判断语句,p当前为子进程的进程号且大于0,进入elsewait()常用来控制父进程与子进程的同步,在父进程中调用wait()则父进程被阻塞,进入等待队列,等待子进程结束,子进程运行到sprintf将字符串存储到字符数组中之后对管道的写入端口加锁解锁,并把字符串数组的内容写入到管道的写入口。

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

之后运行到对管道的读入端加锁,从管道的读入口读出信息放入到inpipe中,输出inpipe.2. 编译运行,把程序运行结果截图,分析程序的执行过程。

分析:父进程先创建管道,再创建两个子进程。

第一个子进程把从键盘接收到的信息写入无名管道,当从键盘接收到首字母为“a”的信息时结束。

第二个子进程从无名管道中读取数据,当从无名管道中读出的首字母为“a”的信息时结束。

父进程利用wait(0),等待两个字进程运行结束后,输出parent is kill退出程序。

进程通信课程设计

进程通信课程设计

进程通信课程设计一、课程目标知识目标:1. 让学生掌握进程通信的基本概念,了解进程与线程的区别及通信机制。

2. 学会使用至少一种进程通信方法,如管道、消息队列、共享内存、信号量等,并理解其工作原理。

3. 掌握进程同步与互斥的概念,了解常见同步互斥机制。

技能目标:1. 培养学生运用进程通信方法解决实际问题的能力,能编写简单的进程通信程序。

2. 提高学生分析进程通信场景,选择合适通信机制的能力。

情感态度价值观目标:1. 培养学生对计算机操作系统及进程通信的兴趣,激发学生主动探索精神。

2. 培养学生具备团队协作意识,能够与同学共同完成进程通信相关的项目任务。

3. 引导学生认识到进程通信在计算机系统中的重要性,增强学生的专业认同感。

课程性质分析:本课程为计算机科学与技术专业课程,旨在让学生深入了解操作系统中进程通信的相关知识。

学生特点分析:学生已具备一定的编程基础和操作系统知识,具有较强的学习能力和动手能力。

教学要求:1. 注重理论与实践相结合,通过实例分析,让学生更好地理解和掌握进程通信技术。

2. 鼓励学生参与课堂讨论,培养学生主动思考和解决问题的能力。

3. 强化实践环节,让学生在实际操作中掌握进程通信技术,提高编程技能。

二、教学内容1. 进程通信基本概念:进程与线程的对比,进程间通信的必要性及常见通信方式。

教材章节:第二章 进程管理,第三节 进程同步与通信2. 进程通信机制:管道、消息队列、共享内存、信号量、信号等。

教材章节:第二章 进程管理,第四节 进程通信机制3. 进程同步与互斥:互斥锁、条件变量、读写锁等同步互斥机制。

教材章节:第二章 进程管理,第五节 进程同步与互斥4. 进程通信实例分析:分析具体场景,选择合适的通信机制,进行实例讲解。

教材章节:第二章 进程管理,第六节 进程通信实例5. 实践环节:编写简单的进程通信程序,加深对进程通信机制的理解。

教材章节:实验教程,实验五 进程通信编程教学进度安排:1. 基本概念与通信机制(2课时)2. 同步互斥机制(2课时)3. 实例分析(2课时)4. 实践环节(4课时)教学内容确保科学性和系统性,结合教材章节,从理论到实践,使学生全面掌握进程通信的相关知识。

进程管理实验报告分析(3篇)

进程管理实验报告分析(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. 实验四:分析利用软中断通信实现进程同步的机理在实验四中,我们分析了利用软中断通信实现进程同步的机理。

进程通信的实验报告

进程通信的实验报告

一、实验目的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. 信号量通信实验结果:父进程成功获取资源,子进程成功释放资源。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

实验五进程间通信实验一、实验目的1、了解什么是信号。

2、熟悉LINUX系统中进程之间软中断通信的基本原理。

3、了解什么是管道4、熟悉UNIX/LINUX支持的管道通信方式二、实验内容1、编写一段程序,使用系统调用fork( )创建两个子进程,再用系统调用signal( )让父进程捕捉键盘上来的中断信号(即按ctrl+c键),当捕捉到中断信号后,父进程用系统调用kill( )向两个子进程发出信号,子进程捕捉到信号后,分别输出下列信息后终止:Child process 1 is killed by parent!Child process 2 is killed by parent!父进程等待两个子进程终止后,输出以下信息后终止:Parent process is killed!<参考程序>#include<stdio.h>#include<signal.h>#include<unistd.h>#include<sys/types.h>#include<sys/wait.h>int wait_mark;void waiting(),stop();void main(){int p1, p2;signal(SIGINT,stop);while((p1=fork())==-1);if(p1>0) /*在父进程中*/{while((p2=fork())==-1);If(p2>0) /*在父进程中*/{wait_mark=1;waiting(0);kill(p1,10);kill(p2,12);wait( );wait( );printf("parent process is killed!\n");exit(0);}else /*在子进程2中*/{wait_mark=1;signal(12,stop);waiting();lockf(1,1,0);printf("child process 2 is killed by parent!\n");lockf(1,0,0);exit(0);}}else /*在子进程1中*/{wait_mark=1;signal(10,stop);waiting();lockf(1,1,0);printf("child process 1 is killed by parent!\n");lockf(1,0,0);exit(0);}}void waiting(){while(wait_mark!=0);}void stop(){wait_mark=0;}实验要求:⑴运行程序并分析结果。

(2分)⑵该程序段前面部分用了两个wait(0),为什么?(1分)⑶该程序段中每个进程退出时都用了语句exit(0),为什么?(1分)答:(1)按下ctrl+c中断进程时,程序才执行,父进程打印消息,父进程kill子进程,子进程1收到消息上锁,然后解锁关闭进程,随后子进程2同样操作,然后父进程打印,最后中断进程。

(2)wait(0)暂时停止目前进程的执行,直到信号来到或子进程结束,如果在调用wait(0)时子进程已经结束,则wait(0)会立即返回子进程结束状态值。

(3)在强调处强行退出程序,运行一次程序就结束。

2、司机售票员问题编程用fork()创建一个子进程代表售票员,司机在父进程中,再用系统调用signal()让父进程(司机)捕捉来自子进程(售票员)发出的中断信号,让子进程(售票员)捕捉来自(司机)发出的中断信号,以实现进程间的同步运行。

(2分)#include <stdio.h>#include <sys/types.h>#include <signal.h>#include <unistd.h>int wait_mark;int pid2;void waiting(), stoping();void main() {int pid1;while ((pid1 = fork()) == -1);if (pid1 > 0) { //司机进程signal(SIGUSR2, stoping);while (1) {wait_mark = 1;sleep(1);printf("drive\n");printf("stop\n");kill(pid1,SIGUSR1); //发送信号给售票员进程; waiting(); //等待来自售票员的信号printf("start\n");printf("\n");}} else { //售票员进程signal(SIGUSR1, stoping);while (1) {wait_mark=1;waiting(); //等待来自司机的信号printf("open\n");printf("sale\n");printf("close\n");pid2 = getppid(); //得到司机进程识别码kill(pid2,SIGUSR2); //发送信号给司机进程}}}void waiting() {while (wait_mark != 0);}void stoping() {wait_mark = 0;}3、编制一段程序,实现进程的管道通信。

使用pipe()建立一条管道线。

两个子进程p1和p2分别向管道各写一句话:Child 1 is sending message!Child 2 is sending message!而父进程则从管道中读出来自于两个子进程的信息,显示在屏幕上。

<参考程序># 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!”);write(fd[1],OutPipe,50);sleep(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);printf(“%s\n”,InPipe);wait(0);read(fd[0],InPipe,50);printf(“%s\n”,InPipe);exit(0);}}}实验要求:运行程序并分析结果。

(1分)答:先使用系统调用fork( )创建两个子进程,再用系统调用signal( )让父进程捕捉键盘上来的中断信号(即按ctrl+c键),当捕捉到中断信号后,父进程用系统调用kill( )向两个子进程发出信号,子进程捕捉到父进程发来的信号后,分别输出下列信息后终止。

4.在父进程中用pipe()建立一条管道线,往管道里写一句话,两个子进程接收这句话。

(2分)# include<unistd.h># include<signal.h># include<stdio.h># include<stdlib.h>#include<sys/wait.h>int pid1,pid2;int main(){int fd[2];char OutPipe[100],InPipe[100];pipe(fd);lockf(fd[1],1,0);printf("parents is sending message!\n");sprintf(OutPipe,"this is pepo parents msg!\n");write(fd[1],OutPipe,50);lockf(fd[1],0,0);while((pid1=fork())== -1||(pid2=fork())== -1);if(pid1==0&&pid2==0){ lockf(fd[0],1,0);read(fd[0],InPipe,50);printf("child 1 process is sending message!\n");printf("child 2 process is sending message!\n");printf("the message is %s\n",InPipe);sleep(3);read(fd[0],InPipe,50);printf("the message is %s\n",InPipe);lockf(fd[0],0,0);exit(0);}}四、实验总结和体会(1分)本次实验过程中遇到了许多编译不能通过的情况,这种情况大部分是因为程序没有应该有的头文件和格式不规范导致的,然后通过实验也了解了信号是不能用于信息交换的,只能用于进程中断控制。

对于信号来源和发送也做了一定了解。

后面两题是关于管道通信,如果两个通信进程不是来自共同的父进程,那么就不能使用管道机制。

相关文档
最新文档