实验二进程通信 Linux实验报告

合集下载

进程间通信实验报告

进程间通信实验报告

软件学院计算机课程实验报告册课程名称计算机操作系统实验学期 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的时间片。

linux进程与线程通讯实验报告

linux进程与线程通讯实验报告

linux 进程与线程通讯实验报告操作系统实验一进程与线程—Linux 进程与线程通讯实验报告操作系统课程设计任务书篇二: 操作系统实验Linux 进程与线程通讯Linux 进程与线程通讯报告人:设计目的1、深刻理解线程和进程的概念2、掌握线程与进程在组成成分上的差别以及与其相适应的通讯方式和应用目标。

设计的内容1、以Linux 系统进程和线程机制为背景,掌握fork() 和clone() 系统调用的2、形式和功能以及与其相适应的高级通讯方式。

由fork 派生的子进程之间通过pipe 通讯,由clone 创建的线程之间通过共享内存通讯,对于后者需要考虑互斥问题。

3、以生产者-消费者问题为例,通过实验理解fork() 和clone() 两个系统调的区别。

程序要求能够创建4 个进程或线程,其中包括两个生产者和两个消费者,生产者和消费者之间能够传递数据。

4、设计准备1、fork 系统调用、pid=fork()创建一个子进程,子进程是父进程的完整复制,正常返回值为非负整数,对于 父进程来说该数大于 0,是子进程的编号 (pid); 对于子进程来说该数为 0。

正是利用反回值的差别可以决定二者不同的后继动作。

2、 clone 系统调用int clone(int (*fn)(void * arg), void *stack, int flags, void * arg);其中 fn 是轻进程所执行的函数, stack 是轻进程所使用的栈, flag 是CLONE_VM, CLONE_FS, CLONE_FILES,LONE_SIGHAND,CLONE_的组合,arg 是调用过程的对应参数。

Clone()的关键是flag 的设定,CLONE_V S 示子进程共享父进程内存,CLONE_F 表示子进程共3、 pipe 系统调用et_val=pipe(fd);参数定义为 int fd[2] 。

创建一个管道文件,返回两个文件描述符 fd[0] 和fd[1] 分别用于管道文件的读和写操作。

《Linux操作系统设计实践》实验二:进程通信

《Linux操作系统设计实践》实验二:进程通信

《Linux操作系统设计实践》实验二:进程通信实验目的:进一步了解和熟悉 Linux 支持的多种 IPC 机制,包括信号,管道,消息队列,信号量,共享内存。

实验环境: redhat实验内容:(1)进程间命名管道通信机制的使用:使用命名管道机制编写程序实现两个进程间的发送接收信息。

(2)进程间消息队列通信机制的使用:使用消息队列机制自行编制有一定长度的消息(1k 左右)的发送和接收程序。

(3)进程间共享存储区通信机制的使用:使用共享内存机制编制一个与上述(2)功能相同的程序。

并比较分析与其运行的快慢。

实验代码验证:(1).使用命名管道机制编写程序实现两个进程间的发送接收信息。

#include <stdio.h>#include <stdlib.h>#define FIFO_FILE "MYFIFO"int main(int argc, char *argv[]){FILE *fp;int i;if (argc<=1){printf("usage: %s <pathname>\n",argv[0]); exit(1);}if ((fp = fopen(FIFO_FILE, "w")) == NULL) {printf("open fifo failed. \n");exit(1);}for (i = 1; i < argc; i++){if (fputs(argv[i],fp) == EOF){printf("write fifo error. \n");exit(1);}if (fputs(" ",fp) == EOF){printf("write fifo error. \n"); exit(1);}}fclose(fp);return 0;}#include <stdio.h>#include <stdlib.h>#include <sys/stat.h>#include <unistd.h>#include <linux/stat.h>#define FIFO_FILE "MYFIFO"int main(){FILE *fp;char readbuf[80];if ((fp = fopen(FIFO_FILE, "r")) == NULL) {umask(0);mknod(FIFO_FILE, S_IFIFO | 0666, 0);}else{fclose(fp);}while (1){if ((fp = fopen(FIFO_FILE, "r")) == NULL) {printf("open fifo failed. \n");exit(1);}if (fgets(readbuf, 80, fp) != NULL){printf("Received string :%s \n", readbuf); fclose(fp);}else{if (ferror(fp)){printf("read fifo failed.\n");exit(1);}}}return 0;}实验结果:Server.c将client.c写入的字符输出。

最新实验二-实验报告(进程管理)

最新实验二-实验报告(进程管理)

最新实验二-实验报告(进程管理)实验目的:1. 理解操作系统中进程的概念及其特性。

2. 掌握进程管理的基本原理和方法。

3. 学习进程创建、撤销、阻塞和唤醒等操作。

4. 熟悉进程间的同步与通信机制。

实验环境:- 操作系统:Linux/Unix- 编程语言:C/C++- 开发工具:GCC编译器,GDB调试器实验内容:1. 创建进程:编写程序,使用系统调用fork()创建子进程,并观察父进程与子进程的行为差异。

2. 进程撤销:实现一个程序,通过系统调用exit()或abort()撤销进程,并观察其对进程组和会话的影响。

3. 进程阻塞与唤醒:设计并实现一个父进程和多个子进程的程序,其中子进程执行阻塞操作(如sleep()),父进程负责唤醒这些子进程。

4. 进程同步:利用信号量或管程等同步机制,实现两个并发进程的同步操作。

5. 进程通信:通过管道(PIPE)、消息队列、共享内存等IPC机制,实现进程间的信息交换。

实验步骤:1. 设计并编写创建进程的程序代码。

2. 在Linux环境下使用GCC编译程序,并记录编译过程。

3. 运行程序,使用GDB等工具调试程序,并观察fork()的执行效果。

4. 实现进程撤销的程序,并记录exit()和abort()的不同行为。

5. 编写进程阻塞与唤醒的程序,并通过实验观察不同进程状态的变化。

6. 完成进程同步的代码实现,并测试死锁及其解决方法。

7. 编写并测试进程通信的程序,确保信息能够正确传递。

实验结果:- 展示创建进程前后的系统状态变化,包括进程表和内存分配情况。

- 记录进程撤销后,父进程收集子进程状态的输出。

- 展示进程阻塞与唤醒的输出结果,验证进程状态转换的正确性。

- 展示进程同步的实验结果,包括死锁的产生与解决。

- 展示进程通信的测试结果,验证信息传递的准确性。

实验分析:- 分析进程创建和撤销的系统资源变化。

- 讨论进程阻塞与唤醒机制的效率和应用场景。

- 探讨进程同步与通信的复杂性及其在多线程编程中的重要性。

操作系统实验2进程管理报告

操作系统实验2进程管理报告

实验一进程管理一、实验目的:1.加深对进程概念的理解,明确进程和程序的区别;2.进一步认识并发执行的实质;3.分析进程争用资源的现象,学习解决进程互斥的方法;4.了解Linux系统中进程通信的基本原理;二、实验预备内容:1.阅读Linux的sched.h源码文件,加深对进程管理概念的理解;2.阅读Linux的fork()源码文件,分析进程的创建过程;三、实验环境说明:1.此实验采用的是Win7(32bit)下虚拟机VMware-workstation-10。

0.4 build-2249910;2.ubuntu 版本3.19。

0;3.直接编写c文件在终端用命令行执行;4.虚拟机分配8G内存中的1024M;5.虚拟机名称knLinux;6.ubuntu用户名kn;四、实验内容:1.进程的创建:a)题目要求:编写一段程序,使用系统调用fork() 创建两个子进程。

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

让每一个进程在屏幕上显示一个字符:父进程显示字符“a”,子进程分别显示字符“b"和“c".试观察记录屏幕上的显示结果,并分析原因。

b)程序设计说明:一个父进程,两个子进程,分别输出显示a,b,c。

c)源代码:d)运行结果:e)分析:由输出结果可知,运行结果不唯一,可以是abc,acb,bca等多种情况。

因为在程序中,并没有三个进程之间的同步措施,所以父进程和子进程的输出顺序是随机的。

在试验次数足够大的情况下,6中顺序都有可能出现:abc, acb, bac,bca,cab, cba.2.进程的控制:a)修改已经编写的程序,将每个进程输出一个字符改为每个进程输出一句话,再观察程序执行时屏幕上出现的现象,并分析原因.i.程序设计说明:将第一个程序中输出字符的语句改为输出parent process和childprocess1&2的语句.ii.源代码:iii.运行结果:iv.分析:发现在结果中,运行结果同第一个程序,但是在一个进程输出语句的中途不会被打断,语句都是完整的。

实验二 进程间通讯 实验报告

实验二 进程间通讯 实验报告

Linux信号量实验报告一、实验目的深入理解操作系统中进程间通讯的本质二、实验方法利用UNIX/LINUX所提供的信号量、共享存储器、PV操作、文件锁等机制实现进程间的信息共享、进程间的互斥与同步。

三、实验任务编写一个C语言程序,该程序将一个存放了一个整数的文本文件内容执行加1操作一百万次,同时启动这个程序的多个副本,观察执行结果是否正确。

利用信号量机制对文件上锁,重新运行观察结果是否正确。

四、实验要点信号量概念、PV操作五、实验内容5.1 信号量概念信号量是一种确保特定代码段(临界区)只能被一个进程或者线程调用的一种机制。

在实际应用中,信号量由一种特殊的数据结构——信号量集所管理。

在使用信号量以前,需要创建一个信号量集,使用完成以后需要销毁信号量集。

信号量集的作用相当于一个信号量的计数器。

P操作是向信号量集获取一个信号量的操作,如果此时信号量集中有信号量,则会对信号量中的计数器进行更改(大部分情况下是计数器减一);如果此时信号量集中没有可用信号量(即计数器为0时),则执行P操作的线程或者进程则会被阻塞,直到信号量集中拥有可用的信号量(即计数器不为0)。

具体关系可用下图表示:5.2 信号量的初始化信号量的初始化需要用到两个函数(semget和semctl)和一个联合体结构(该实验中我们只需要用联合体结构中的val值,所以我只定义val变量)。

Semget系统调用的定义如下:int semget(key_t key, int nsems, int semflg)semget这个系统调用的作用是返回一个与key参数相关联的一个信号量集标识,semflg 参数会控制函数的行为;如果semflg为IPC_CREAT或者IPC_PRIVATE,则函数会创建一个拥有nsems个信号量的信号量集;如果semflg的值为IPC_CREAT | IPC_EXCL,在信号量集已经存在的情况下会发生错误。

实验中使用的获得信号量集标识的代码为:int sem_id = semget((key_t)2234, 0, 0);if (sem_id == -1){sem_id = semget((key_t)2234, 1, 0666 | IPC_CREAT);if (!init(sem_id)) return -1;}上述代码的第一行,nsems和semflg参数均为0,目的是只获得与2234这个值相关联的信号量集的标识;如果这个信号量集已经存在,则返回这个信号量集的标识;否则返回-1 下面就对获得的sem_id进行判断,如果值为-1,即信号量集还没有被创建,需要创建一个信号量集。

实验二 Linux进程通信

实验二 Linux进程通信

实验二 Linux进程通信一、实验目的1)了解有关Linux系统调用;2)学习有关Linux的进程创建,理解进程创建后两个并发进程的执行。

二、实验内容在Linux环境下,用C/C++语言编程,使用系统调用fork创建进程多个子进程。

(1) 调试并完成下列程序,完成实验要求:#include "stdio.h"#include "sys/types.h"#include "unistd.h"int main(){pid_t pid1;pid_t pid2;pid1 = fork();pid2 = fork();printf("pid1:%d, pid2:%d\n", pid1, pid2);}要求:A.请说出执行这个程序后,将一共运行几个进程。

B.观察运行结果,并给出分析与解释。

答:A.执行这个程序后,将一共运行4个进程。

A.运行结果如下:分析与解释:fork()函数能够建立子进程,且使得子进程得到父进程地址空的一个复制;而且,当创建成功时,如果是父进程则返回0,子进程则返回子进程的I D,但是,fork()创建的进程并不是从该程序开头开始执行,它只是和父进程一样继续执行后续代码,因此在之后的语句中,父子进程同时创建一个进程,就形成了四个进程,如图上所示。

所以,,在上面的截图中,第一次fork()函数时成功产生了父子进程pid分别为2775和0,第二次使用fork()函数时父子进程又各产生了一对父子进程父进程产生的父子进程的pid分别为2776和0,子进程产生的父子进程的pid分别为0和2777。

因为进程是并发的,他的调度我们无法干预,所以出现的结果并非都是一成不变的,执行多次后,输出的顺序有可能不一样。

(2)参考下面的相关程序实例,编写一个管道实验程序,实现两个进程之间的数据通信。

要求:父进程顺序写入若干个字符串,子进程顺序读出内容,并写入文件piple.txt,并显示出来。

试验二进程通信Linux试验报告

试验二进程通信Linux试验报告

实验报告学号姓名成绩__________实验二进程通信【实验目的和要求】1、了解进程通信的概念及方法;2、了解信号量、管道;3、掌握信号量、管道和命名管道编程方法。

【实验内容】1、利用命名管道实现单机QQ聊天;2、撰写实验报告;【实验原理】1、信号量(semaphore)是为那些访问相同资源的进程以及同一进程不同线程之间提供的一个同步机制。

它不是用于传输数据,而只是简单地协调对共享资源的访问。

信号量包含一个计数器,表示某个资源正在被访问和访问的次数,用来控制多进程对共享数据的访问。

一旦成功拥有了一个信号量,对它所能做的操作只有两种:请求和释放。

当执行释放操作时,系统将该信号值减1(如果小于零,则设置为零);当执行请求操作时,系统将该信号值加1,如果加1后的值大于设定的最大值,那么系统将会挂起处理进程,直到信号值小于最大值为止。

Tuxedo 用信号量来确保在某一时刻只有一个进程对某一块共享内存进程访问。

信号量配置太低会导致Tuxedo系统应用程序无法启动。

2、管道分为两种:管道和命名管道。

管道是UNIX系统IPC的最古老形式,并且所有的UNIX系统都提供这种通信机制。

可以在有亲缘关系(父子进程或者是兄弟进程之间)进行通信,管道的数据只能单向流动,如果想双向流动,必须创建两个管道。

管道应用的一个重大缺陷就是没有名字,因此只能用于亲缘进程之间的通信。

后来以管道为基础提出命名管道(namedpipe,FIFO)的概念,该限制得到了克服。

FIFO不同于管道之处在于它提供一个路径名与之关联,以FIFO的文件形式存在于文件系统中。

这样,即使与FIFO的创建进程不存在亲缘关系的进程,只要可以访问该路径,就能够彼此通过FIFO相互通信(能够访问该路径的进程以及FIFO的创建进程之间),因此,通过FIFO不相关的进程也能交换数据。

值得注意的是,FIFO严格遵循先进先出(first in first out)规则,对管道及FIFO的读总是从开始处返回数据,对它们的写则是把数据添加到末尾。

进程通信的实验报告

进程通信的实验报告

一、实验目的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篇)

进程通讯管理实验报告(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()函数删除消息队列。

操作系统实验报告2-进程间通信

操作系统实验报告2-进程间通信
*pint=pid;
msg.mtype=1;
msgsnd(msgqid,&msg,sizeof(int),0);
msgrcv(msgqid,&msg,256,pid,0);
printf("client:receive from pid %d\n",*pint);
exit(0);
}
#include<sys/types.h>
信号本质:信号是在软件层次上对中断机制的一种模拟,在原理上,一个进程收到一个信号与处理器收到一个中断请求可以说是一样的。信号是异步的,一个进程不必通过任何操作来等待信号的到达,事实上,进程也不知道信号到底什么时候到达。信号是进程间通信机制中唯一的异步通信机制,可以看作是异步通知,通知接收信号的进程有哪些事情发生了。信号机制经过POSIX实时扩展后,功能更加强大,除了基本通知功能外,还可以传递附加信息。进程用kill( )向一个进程或一组进程发送一个信号;当一个进程要进入或退出一个低优先级睡眠状态时,或一个进程即将从核心态返回用户态时,核心都要检查该进程是否已收到软中断
signal(17,stop); /*接收到软中断信号17,转stop*/
waiting( );
lockf(stdout,1,0);
printf("Child process 2 is killed by parent!\n");
lockf(stdout,0,0);
exit(0);
}
}
else
{
wait_mark=1;
signal(16,stop); /*接收到软中断信号16,转stop*/
waiting( );
lockf(stdout,1,0);

Linux进程通信实验报告

Linux进程通信实验报告

三、 实验环境
一台安装了 Red Hat Linux 9 操作系统的计算机。
四、 实验操作方法和步骤
进入 Linux 操作系统,利用 vi 编辑器将程序源代码输入并保存好,然后 打开终端对程序进行编译运行。
五、 实验中遇到的问题及解决 六、 实验结果及分析
基本实验
可选实验
七、 源代码
Pipe.c #include"stdio.h" #include"unistd.h" main(){ int i,j,fd[2]; char S[100]; pipe(fd); if(i=fork==0){ sprintf(S,"child process 1 is sending a message \n"); write(fd[1],S,50); sleep(3); return; } if(j=fork()==0){ sprintf(S,"child process 2 is sending a message \n"); write(fd[1],S,50); sleep(3); return;
}else{ wait(0); read(fd[0],S,50); printf("%s",S); read(fd[0],S,50); printf("%s",S); return; } } Softint.c #include"stdio.h" #include"unsitd.h" main(){ int i,j,fd[2]; char S[100]; pipe(fd); if(i=fork==0){ sprintf(S,"child process 1 is sending a message \n"); write(fd[1],S,50); sleep(3); return; } if(j=fork()==0){ sprintf(S,"child process 2 is sending a message \n"); write(fd[1],S,50); sleep(3); return; }else{ wait(0); read(fd[0],S,50); printf("%s",S); read(fd[0],S,50); printf("%s",S); return;}Leabharlann }Linux 进程通信实验报告

操作系统实验报告_Linux进程创建与通信

操作系统实验报告_Linux进程创建与通信

2011-2012学年第一学期计算机操作系统实验报告专业:班级:学号:姓名:提交日期:2011年11月1实验二Linux进程创建与进程通信【实验目的】1. 熟悉有关Linux系统调用;2. 学习有关Linux的进程创建,理解进程创建后两个并发进程的执行;3. 通过系统调用wait()和exit(),实现父子进程同步;4. 掌握管道、消息缓冲等进程通信方法并了解其特点和使用限制。

【实验内容】1. 父进程创建子进程实现父进程创建一个子进程,返回后父子进程分别循环输出字符串“The parent process.”及“The child process.”5次,每次输出后使用sleep(1)延时一秒,然后再进入下一次循环。

给出源程序代码和运行结果。

程序代码:main(){int p1,i;while ((p1=fork())==-1);if (p1>0)for (i=0;i<5;i++){printf("I am parent.\n");sleep(1);}elsefor (i=0;i<5;i++){printf("I am child.\n");sleep(1);}}运行结果:The parent process.The child process.The parent process.The child process.The parent process.The child process.The parent process.The child process.The parent process.The child process.2. 父子进程同步修改上题程序,使用exit()和wait()实现父子进程同步,其同步方式为父进程等待子进程的同步,即:子进程循环输出5次,然后父进程再循环输出5次。

给出源程序代码和运行结果。

程序代码:main(){int p1,i;while ((p1=fork())==-1);if (p1>0){wait(0);for (i=0;i<5;i++){printf("I am parent.\n");sleep(1);}}else{for (i=0;i<5;i++){printf("I am child.\n");sleep(1);}exit(0);}}运行结果:I am parent.I am parent.I am parent.I am parent.I am parent.I am child.I am child.I am child.I am child.I am child.3. Linux管道通信编写一个程序,实现以下功能。

linux进程与线程通讯实验报告

linux进程与线程通讯实验报告

linux 进程与线程通讯实验报告操作系统实验一进程与线程—Linux 进程与线程通讯实验报告操作系统课程设计任务书篇二: 操作系统实验Linux 进程与线程通讯Linux 进程与线程通讯报告人:设计目的1、深刻理解线程和进程的概念2、掌握线程与进程在组成成分上的差别以及与其相适应的通讯方式和应用目标。

设计的内容1、以Linux 系统进程和线程机制为背景,掌握fork() 和clone() 系统调用的2、形式和功能以及与其相适应的高级通讯方式。

由fork 派生的子进程之间通过pipe 通讯,由clone 创建的线程之间通过共享内存通讯,对于后者需要考虑互斥问题。

3、以生产者-消费者问题为例,通过实验理解fork() 和clone() 两个系统调的区别。

程序要求能够创建4 个进程或线程,其中包括两个生产者和两个消费者,生产者和消费者之间能够传递数据。

4、设计准备1、fork 系统调用、pid=fork()创建一个子进程,子进程是父进程的完整复制,正常返回值为非负整数,对于 父进程来说该数大于 0,是子进程的编号 (pid); 对于子进程来说该数为 0。

正是利用反回值的差别可以决定二者不同的后继动作。

2、 clone 系统调用int clone(int (*fn)(void * arg), void *stack, int flags, void * arg);其中 fn 是轻进程所执行的函数, stack 是轻进程所使用的栈, flag 是CLONE_VM, CLONE_FS, CLONE_FILES,LONE_SIGHAND,CLONE_的组合,arg 是调用过程的对应参数。

Clone()的关键是flag 的设定,CLONE_V S 示子进程共享父进程内存,CLONE_F 表示子进程共3、 pipe 系统调用et_val=pipe(fd);参数定义为 int fd[2] 。

创建一个管道文件,返回两个文件描述符 fd[0] 和fd[1] 分别用于管道文件的读和写操作。

实验二 进程通信实验

实验二  进程通信实验

实验二进程通信实验1.实验内容设有二元函数f(x,y) = f(x) + f(y)其中:f(x) = f(x-1) * x (x >1)f(x)=1 (x=1)f(y) = f(y-1) + f(y-2) (y> 2)f(y)=1 (y=1,2)请编程建立3 个并发协作进程,它们分别完成f(x,y)、f(x)、f(y) 2.实验代码(附件中)3.在当前目录中建立Makefile文件5.使用make命令编译连接生成可执行文件pipetest6.编译成功后执行pipetest7实验要求(1)进程协作:系统中一个进程能影响其他进程或被其他进程所影响,那么该进程是协作的。

在该实验中,子进程x和子进程y 需要来自父进程传输的自变量x和y,而父进程的完成需要来自子进程x和子进程y的计算结果f(x)和f(y),所以父进程和两个子进程是协作的。

协作进程需要一种进程间通信机制来允许进程相互交换数据与信息。

(2)在实验中采用管道通信,管道是一个单向通信信道,如果进程间要进行双向通信,通常需要定义两个管道。

管道通过系统调用read(), write()函数进行读写操作。

管道通信机制的机理:一种半双工的通信机制,两个进程可以通过管道一个在管道一端向管道发送其输出,给另一进程可以在管道的另一端从管道得到其输入;另外,管道只能用来在具有公共祖先的两个进程之间通信。

管道通信遵循先进先出的原理,并且数据只能被读取一次,当此段数据被读取后,马上会从数据中消失,当管道中的数据被读取后,管道为空,一个随后的read()调用将默认的被阻塞,并等待某些数据写入。

通常会先调用pipe(),然后调用fork(),从而创建从父进程到子进程的IPC通道.。

操作系统实验 进程通信

操作系统实验 进程通信

进程通信(实验二)【实验目的】:掌握用邮箱方式进行进程通信的方法,并通过设计实现简单邮箱理解进程通信中的同步问题以及解决该问题的方法。

【实验原理】:邮箱机制类似于日常使用的信箱。

对于用户而言使用起来比较方便,用户只需使用send()向对方邮箱发邮件receive()从自己邮箱取邮件,send()和receive()的内部操作用户无需关心。

因为邮箱在内存中实现,其空间有大小限制。

其实send()和receive()的内部实现主要还是要解决生产者与消费者问题。

【实验内容】:进程通信的邮箱方式由操作系统提供形如send()和receive()的系统调用来支持,本实验要求学生首先查找资料了解所选用操作系统平台上用于进程通信的系统调用具体形式,然后使用该系统调用编写程序进行进程间的通信,要求程序运行结果可以直观地体现在界面上。

在此基础上查找所选用操作系统平台上支持信号量机制的系统调用具体形式,运用生产者与消费者模型设计实现一个简单的信箱,该信箱需要有创建、发信、收信、撤销等函数,至少能够支持两个进程互相交换信息,比较自己实现的信箱与操作系统本身提供的信箱,分析两者之间存在的异同。

实验背景介绍进程间通信有如下目的:数据的传输,共享数据,通知事情,资源共享,进程控制。

进程间的通信机制(IPC),就是多进程相互通信,交换信息的方法。

Linux IPC机制包括,信号和管道是其中的两个,还支持传统的UNIX SYSTM-V 的IPC 机制。

信号主要用来通知进程异步事情的发生,最初信号设计的目的是为了处理错误,他们也用来作为最基本的IPC机制。

管道是单向的,先进先出,先入先出,无结构的,固定大小的数据流。

UNIX System V 机制中的三种进程间通信机制,它们是:消息队列:用于进程之间传递分类的格式化数据信号量:用于通信之间的同步控制。

信号量通常与共享存储器方式一起使用。

共享内存:使不同进程通过共享彼此的虚拟空间而达到相互对共享区操作和数据通信。

Linux父子进程通信实验 实验报告

Linux父子进程通信实验 实验报告
源代码:
// main.c #include <sys/wait.h> #include <assert.h> #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <string.h> #include <time.h> #define PIPE_WRITE_PORT 1 #define PIPE_READ_PORT 0
}
childPid = fork(); if(childPid == -1 ) {
perror("fork"); exit(EXIT_FAILURE); } else if( childPid ==0 ) { close(pipefd[PIPE_WRITE_PORT]); ChildProcess( pipefd[PIPE_READ_PORT] ); } else { close(pipefd[PIPE_READ_PORT]); ParentProcess( childPid, pipefd[PIPE_WRITE_PORT] ); } return 0; }
父进程输出当前的时间和日期父进程输出自己的进程号和子进程的进程号子进程输出自己的进程号让子进程执行另外一个程序
实验二 Linux 程序通信 上机报告
实验环境:
操作系统 Ubuntu 8.04 vmlinuz-2.6.28-15 编译环境 Eclipse 3.4.0 CDT 5.0
实验要求:
父进程输出当前的时间和日期 父进程输出自己的进程号和子进程的进程号 子进程输出自己的进程号 让子进程执行另外一个程序。 父进程创建一个 pipe,父子进程通过 pipe 通信,父进程将自己的进程号传递给子进程,子 进程将读到的进程号输出。
  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

实验报告学号_____ 姓名____ ___ 成绩实验二进程通信【实验目的和要求】1、了解进程通信的概念及方法;2、了解信号量、管道;3、掌握信号量、管道和命名管道编程方法。

【实验内容】1、利用命名管道实现单机QQ聊天;2、撰写实验报告;【实验原理】1、信号量(semaphore)是为那些访问相同资源的进程以及同一进程不同线程之间提供的一个同步机制。

它不是用于传输数据,而只是简单地协调对共享资源的访问。

信号量包含一个计数器,表示某个资源正在被访问和访问的次数,用来控制多进程对共享数据的访问。

一旦成功拥有了一个信号量,对它所能做的操作只有两种:请求和释放。

当执行释放操作时,系统将该信号值减1(如果小于零,则设置为零);当执行请求操作时,系统将该信号值加1,如果加1后的值大于设定的最大值,那么系统将会挂起处理进程,直到信号值小于最大值为止。

Tuxedo 用信号量来确保在某一时刻只有一个进程对某一块共享内存进程访问。

信号量配置太低会导致Tuxedo系统应用程序无法启动。

2、管道分为两种:管道和命名管道。

管道是UNIX系统IPC的最古老形式,并且所有的UNIX系统都提供这种通信机制。

可以在有亲缘关系(父子进程或者是兄弟进程之间)进行通信,管道的数据只能单向流动,如果想双向流动,必须创建两个管道。

管道应用的一个重大缺陷就是没有名字,因此只能用于亲缘进程之间的通信。

后来以管道为基础提出命名管道(named pipe,FIFO)的概念,该限制得到了克服。

FIFO不同于管道之处在于它提供一个路径名与之关联,以FIFO的文件形式存在于文件系统中。

这样,即使与FIFO的创建进程不存在亲缘关系的进程,只要可以访问该路径,就能够彼此通过FIFO相互通信(能够访问该路径的进程以及FIFO的创建进程之间),因此,通过FIFO不相关的进程也能交换数据。

值得注意的是,FIFO严格遵循先进先出(first in first out)规则,对管道及FIFO的读总是从开始处返回数据,对它们的写则是把数据添加到末尾。

它们不支持诸如lseek()等文件定位操作。

【程序代码】1、lucy.c#include<stdio.h>#include<sys/stat.h>#include<string.h>#include<sys/types.h>#include<errno.h>#include<fcntl.h>#include<unistd.h>#include<stdlib.h>char write_fifo_name[]="ltop_fifo";char read_fifo_name[]="ptol_fifo";char writer[]="Lucy";char reader[]="Peter";int main(int argc,char *argv[]){int write_fd,read_fd;mkfifo(write_fifo_name,S_IRUSR|S_IWUSR);mkfifo(read_fifo_name,S_IRUSR|S_IWUSR);printf("hello,I am lucy!\n");write_fd=open(write_fifo_name,O_WRONLY);if(write_fd<0){perror("open_w");exit(-1);}read_fd=open(read_fifo_name,O_RDONLY);if(read_fd<0){perror("open_r");exit(-1);}pid_t pid;pid=fork();if(pid==0){while(1){char bufw[256]="";printf("%s:",writer);if(fgets(bufw,256,stdin)==NULL)exit(1);bufw[strlen(bufw)-1]='\0';write(write_fd,bufw,strlen(bufw));if(strncmp(bufw,"bye",3)==0){close(write_fd);unlink(write_fifo_name);exit(1);}}}else{while(1){char bufr[256]="";read(read_fd,bufr,256);printf("\r%s:%s\n",reader,bufr);if(strncmp(bufr,"bye",3)==0){write(write_fd,"bye",4);close(read_fd);unlink(read_fifo_name);exit(1);}printf("%s:",writer);fflush(stdout);}}return 0;}2、peter.c#include<stdio.h>#include<sys/stat.h>#include<string.h>#include<sys/types.h>#include<errno.h>#include<fcntl.h>#include<unistd.h>#include<stdlib.h>char write_fifo_name[]="ptol_fifo";char read_fifo_name[]="ltop_fifo";char writer[]="Peter";char reader[]="Lucy";int main(int argc,char *argv[]){int write_fd,read_fd;mkfifo(write_fifo_name,S_IRUSR|S_IWUSR);mkfifo(read_fifo_name,S_IRUSR|S_IWUSR);printf("hello,I am peter!\n");read_fd=open(read_fifo_name,O_RDONLY); if(read_fd<0){perror("open_r");exit(-1);}write_fd=open(write_fifo_name,O_WRONLY); if(write_fd<0){perror("open_w");exit(-1);}pid_t pid;pid=fork();if(pid==0){while(1){char bufw[256]="";printf("%s:",writer);if(fgets(bufw,256,stdin)==NULL)exit(1);bufw[strlen(bufw)-1]='\0';write(write_fd,bufw,strlen(bufw));if(strncmp(bufw,"bye",3)==0){close(write_fd);unlink(write_fifo_name);exit(1);}}}else{while(1){char bufr[256]="";read(read_fd,bufr,256);printf("\r%s:%s\n",reader,bufr);if(strncmp(bufr,"bye",3)==0){write(write_fd,"bye",4);close(read_fd);unlink(read_fifo_name);exit(1);}printf("%s:",writer);fflush(stdout);}}return 0;}【实验步骤】1、程序lucy.c创建了FIFO write_fifo用于向程序peter.c发送消息;peter.c程序创建了FIFO read_fifo用于向lucy.c发送消息;同时,lucy.c能够通过打开peter.c创建的FIFO来得到的peter.c发来的消息,peter.c能够通过打开lucy.c 创建的FIFO来得到lucy.c发来的消息。

因此两者就能互相通信了,两者必须在线才能进行通信聊天,这个与qq的聊天功能有些类似。

2、将lucy.c和peter.c的代码编写完后,在一个终端调试即gcc lucy.c –o lucy,无错误后运行./lucy;在另外一个新终端上调试即gcc peter.c –o peter,无错误后运行./peter;开始进行聊天,若想结束聊天,则在一个终端上输入bye,俩个终端就会同时关闭。

【实验结果】【实验体会】传统的进程间通信方式:无名管道pipe、有名管道fifo和信号signal。

管道的编程1、无名管道创建一个简单的管道,可以使用系统调用pipe()。

它接受一个参数,也就是一个包括两个整数的数组。

如果系统调用成功,此数组将包括管道使用的两个文件描述符。

创建一个管道之后,一般情况下进程将产生一个新的进程。

系统调用:pipe();注意:fd[0]用于读取管道,fd[1]用于写入管道。

该函数创建的管道的两端处于一个进程中间,在实际应用中没有太大意义,因此,一个进程在由pipe()创建管道后,一般再fork一个子进程,然后通过管道实现父子进程间的通信(因此也不难推出,只要两个进程中存在亲缘关系,这里的亲缘关系指的是具有共同的祖先,都可以采用管道方式来进行通信)。

一般文件的I/O函数都可以用于管道,如close、read、write等等。

2、有名管道创建有名管道用mkfifo()。

创建有名管道用mkfifo()。

头文件#include <sys/stat.h>#include <sys/types.h>函数原型int mkfifo(const char * pathname, mode_t mode)函数传入值Pathname:要创建的的管道Mode:设置管道权限函数返回值若成功则为0,若出错返回-1FIFO相关出错信息:EACCES(无存取权限)EEXIST(指定文件不存在)ENAMETOOLONG(路径名太长)ENOENT(包含的目录不存在)ENOSPC(文件系统余空间不足)ENOTDIR(文件路径无效)EROFS(指定的文件存在于只读文件系统中)3、信号发送和捕捉信号发送:kill()和raise()kill()函数同读者熟知的kill系统命令一样,可以发送信号给进程或进程组,它不仅可以中止进程(实际上发出SIGKILL信号),也可以向进程发送其他信号。

相关文档
最新文档