实验3_进程并发与同步

合集下载

实验三 进程同步

实验三   进程同步

集美大学诚毅学院信息工程系实验报告课程名称计算机操作系统序号名称实验三进程同步姓名孙幸杰学号2011957032专业计算1191 日期13.11.22成绩教师洪联系评语:1.实验目的:掌握用Linux信号灯集机制实现两个进程间的同步问题2.实验环境Win7系统虚拟机下运行的Linux系统。

3.实验内容司机与售票员问题是两个进程的同步问题,司机要启动汽车前,要检查售票员车门是否已经关好;售票员要打开车门之前要等司机把车停稳.要求:需要的信号灯: System V信号灯实现用于控制司机是否可以启动车辆的的信号灯 S1=0用于控制售票员是否可以开门的信号灯 S2=04.实验程序(有详细注释)//---------------------------------------------------//这是一个公共汽车的驾驶员与售票员之间的同步问题//一个进程模拟驾驶员,一个进程模拟售票员;//驾驶员的动作:启动车辆--驾驶车辆--到站停车//售票员的动作:关门--售票--开门;//售票员把车门关好后,驾驶员才能启动汽车;//当驾驶员在一个站把车子停稳后,售票员方能打开车门;////本程序采用System V的信号灯集实现两者的同步// 2010.10.8//-----------------------------------------------------#include <sys/types.h>#include <sys/ipc.h>#include <sys/sem.h>#include <stdio.h>#include <time.h>#include <stdlib.h>union semun{int val;//仅用于SETVAL命令struct semid_ds *buf;//用于IPC_SET等命令ushort *array;//用于SETALL等命令};//用于信号灯初始化//semid--信号灯的ID//val--欲设置的信号灯初值//sn--信号灯集的分量void seminit(int semid,int val,int sn) {union semun arg;arg.val=val;semctl(semid,sn,SETVAL,arg);};//实现信号灯的P操作//semid--信号灯的ID//sn--信号灯集的分量void semdown(int semid,int sn){/* define P operating*/struct sembuf op;op.sem_num=sn;op.sem_op=-1;//P操作为-1op.sem_flg=0;semop(semid,&op,1);}//实现信号灯的V操作//semid--信号灯的ID// sn--信号灯集的分量void semup(int semid, int sn){/*define V operating*/struct sembuf op;op.sem_num=sn;op.sem_op=1;//V操作为1op.sem_flg=0;semop(semid,&op,1);}main(){int i,j;key_t semkey;char *pathname="./driver.c";int semid;int rrand;srand((int)time(0));//用于产生随机延时 semkey=ftok(pathname,45);if(semkey==-1){printf("Error:create a key error!\n");exit(-1);}semid=semget(semkey,2,IPC_CREAT | 0666);if(semid==-1){printf("Error:create semaphore error!\n");exit(-1);}seminit(semid,0,0);//对信号灯集的0号分量进行初始化seminit(semid,0,1);//对信号灯集的1号分量进行初始化if(fork()==0) //Create a process{//子进程作为驾驶员进程for(i=1;i<10;i++){semdown(semid,0);//等待售票员关门printf("Driver(pid:%d): Start the bus.\n",getpid());printf("Driver(pid:%d): Traveling....\n",getpid());rrand=1+(int)(6.0*rand()/(RAND_MAX+1.0));//产生一个(1-6)的随机数表示车辆的行驶时间sleep(rrand);printf("Driver(pid:%d): Arrive at a station. stop!\n",getpid()); semup(semid,1);//唤醒售票员}}else{//父进程作为售票员进程for(j=1;j<10;j++){printf("Conductor(pid:%d):Close all doors.\n",getpid());semup(semid,0);//唤醒司机printf("Conductor(pid:%d):Ticketing...\n",getpid());semdown(semid,1); //等待汽车到站printf("Conductor(pid:%d):Open all doors.\n",getpid());sleep(1);}}}5.实验结果及其分析输入程序:程序:编译:运行结果:6.实验小结完成本实验后,我对基本的额进程间的通信有了初步的了解。

实验三-进程通讯实验报告

实验三-进程通讯实验报告

实验三进程通讯实验报告【姓名】【学号】【实验题目】进程通讯——消息队列与共享存储区【实验目的】(1)掌握进程间通讯的编程方法;(2)加深对进程并发执行的理解;(3)学习利用消息队列和共享存储区实现进程通信的方法。

【实验内容】设计一个多进程并发运行的程序,它由不同的进程完成下列工作:(1)接收键盘输入进程负责接收用户的键盘输入,并以适当的方式将由键盘获得的数据交给其它进程处理。

(2)显示进程负责全部数据显示任务,包括键盘输入数据的显示和提示信息的显示。

(3)分发数据进程将键盘输入的数据分为3类,即字母、数字和其它,并分别将字母写入文件letter.txt 中,数字写入文件number.txt中,除字母和数字外其它数据丢弃。

【实验要求】1、程序能以适当的方式提示用户输入数据;2、提示用户有数据被丢弃;3、全部的显示任务必须由显示进程完成;4、整个程序能够连续处理多组输入数据,直到用户输入“quit”字符串,整个程序结束;5、进一步要求:同时采用共享存储区和消息2种方法实现进程之间的通信,并比较这2种通信方法的利弊。

【实验方法】1、利用fork()函数创建2个子进程,用一个父进程和两个子进程完成上面的三个实验任务,用子进程1实现分发数据任务,子进程2实现接受键盘输入任务,父进程实现全部的显示任务。

2、同时通过共享存储区和消息队列两种进程通讯方式实现上面三个进程之间的同步和互斥。

3、利用while()循环、kill()函数和signal()函数实现连续多组数据输入。

【程序结构】·数据结构:消息队列、字符数组;·程序结构:顺序结构、if-else分支结构和while循环结构;·主要算法:无特别算法【实验结果】1、有代表性的执行结果:[stud13@localhost stud13]$ cc ipc.c[stud13@localhost stud13]$ ./a.outPlease input a line:∟operatingsystem01234-=,.Your message is:operatingsystem01234-=,.The characters deserted are:-=,.Please input a line:∟xushengju6651001!@#$%^&*()Your message is:xushengju6651001!@#$%^&*()The characters deserted are:!@#$%^&*()Please input a line:∟Hello123Your message is:Hello123Please input a line:∟quit[stud13@localhost stud13]$ cat letter.txtOperatingsystemxushengjuHello[stud13@localhost stud13]$ cat number.txt 012346651001123[stud13@localhost stud13]$2、结果分析及解释:在创建子进程1时,由于先返回子进程的ID号,msgrcv(msgid,&msg,BUFSIZE,0,0)一直都是非0值,故循环等待。

进程同步问题总结

进程同步问题总结

进程同步问题总结进程同步问题主要涉及到并发进程之间的协作和同步,以实现多进程的协同工作。

以下是进程同步问题的主要总结:1.进程同步的概念:进程同步是一种协调多个进程运行顺序的机制。

它使得进程能够在正确的时间点上,按照一定的顺序进行交互和协作。

2.进程同步的必要性:在多进程环境中,如果不同进程的执行顺序不协调,就可能导致数据不一致、竞争条件等问题。

进程同步可以解决这些问题,保证多进程环境下的正确性和可靠性。

3.进程同步的主要方法:a) 信号量(Semaphore):信号量是一种计数器,用于控制多个进程对共享资源的访问。

信号量的值表示当前可用的共享资源数量。

通过设置信号量的初始值和使用P、V操作(或称为wait和post操作),可以实现进程的同步和互斥。

b) 互斥锁(Mutex):互斥锁是一种同步机制,用于防止多个进程同时访问共享资源。

当一个进程获得锁时,其他进程将被阻塞,直到锁被释放。

c) 条件变量(Condition):条件变量用于实现进程间的条件等待。

当一个进程需要等待某个条件成立时,它会使用条件变量的wait操作阻塞自己。

当另一个进程改变了条件并通知等待的进程时,被阻塞的进程将被唤醒。

d) 事件(Event):事件是一种同步机制,用于通知其他进程某个事件已经发生。

事件通常分为信号事件和广播事件。

信号事件只通知一个进程,而广播事件通知所有等待该事件的进程。

4.死锁问题:在进程同步过程中,如果多个进程互相等待对方释放资源,就会产生死锁问题。

避免死锁的方法包括:避免循环等待、按顺序申请资源、设置超时时间等。

5.进程同步的应用:进程同步广泛应用于操作系统、并发程序设计、网络通信等领域。

例如,在操作系统中,进程同步可以用于实现进程调度、任务管理、文件系统等重要功能。

在并发程序设计中,进程同步可以用于实现多线程的协同工作、数据访问控制等功能。

在网络通信中,进程同步可以用于实现数据传输、远程过程调用等功能。

进程同步:实验报告

进程同步:实验报告

1.实验内容(进程的同步)(1)阅读理解示例程序。

(2)说明示例程序是否能适合解决N个生产者和1个消费者问题,并设计实验验证(3) 参照教材修改为N个生产者和1个消费者问题(4) 思考N个生产者和M个消费者问题的解决方案(不要求)(5) 利用信号量解决同步问题。

2.实验目的通过程序模拟及验证生产者消费者问题等经典问题,深入理解并发中的同步和互斥的概念3.实验原理(1)进程概念:(1.定义:程序的一次执行过程(2.三种基本状态:就绪状态,执行状态,阻塞状态(2)进程同步:(1.定义:并发进程在执行次序上的协调,以达到有效的资源共享和相互合作,使程序执行有可再现性。

(2.两种形式的制约关系:(一:资源共享关系:进程间接制约,需互斥地访问临界资源。

)、(二:相互合作关系:进程直接制约)(3.临界资源:一次仅允许一个进程访问的资源,引起不可再现性是因为临界资源没有互斥访问。

(3)信号量:定义一个用于表示资源数目的整型量S,它与一般的整型量不同,除初始化外,仅能通过两个标准的原子操作wait(S)和signal(S)来访问,俗称P,V操作。

通俗来讲就是用P来访问资源后减去一个单位资源,用V操作来释放一个单位资源就是现有资源上加一个单位资源。

4.实验内容一:说明示例程序是否能适合解决N个生产者和1个消费者问题,并设计实验验证答:示例程序不能解决多个生产者和消费者的问题,它是解决单个消费者和生产者的。

如果可以就要修改代码,如“二”所说。

二:多个消费者和生产者的问题如上图所示:如果要解决多个生产者和消费者的问题:第一步:分析上图得出了两种关系,分别是异步和同步的关系第二步:异步关系的是生产者和生产者之间的,因为同一时刻只能有一个生产者访问缓冲区,所以我们就可以设置临界资源.获得临界资源的生产者才能把产品放到缓冲区里第三步:同步关系有两个,首先是生产者和缓冲区之间,再是缓冲区和消费者之间。

他们都满足一前一后的关系,即当缓冲区空间未满时,生产者才可以放产品;缓冲区不为空的时候才可以让消费者取出产品消费。

操作系统进程调度和进程同步实验要求

操作系统进程调度和进程同步实验要求

0711操作系统进程调度和进程同步实验要求实验内容:用线程模拟进程,实现进程调度和进程同步。

在任意操作系统中,用c、c++或者java 编写程序。

并且完成相应的实验报告。

实验要求:实验一:进程调度⑴ 主线程,创建子线程,保存子线程的虚拟PCB(参见恐龙书P74)、要求运行多少时间(可随机产生)、已经等待多少时间(初始化为0),优先级(可随机产生)等信息,并负责子线程的调度。

调度的基本时间单位为1 S。

⑵ 创建20个线程(可以只用一个线程函数,传递不同的参数即上述数据结构)分别实现FCFS调度、SJF调度、RR调度、优先级调度和多级队列调度,并且计算每个调度的平均等待时间。

其中,多级队列调度要求设计4个调度队列,每个队列5个线程,队列内部分别采用FCFS、SJF、RR和优先级调度。

时间片的长度可以随机生成为n S。

⑶ 对于每个子线程,在其运行期间,输出其占用的时间标号(例如,第3个线程占用了第10秒的CPU时间,输出为:“Thread 3: 10”,格式可自行设计)。

实验二:进程同步⑴ 模拟哲学家就餐问题:设置5个子线程模拟5个哲学家,设置5个互斥区为筷子。

⑵ 输出问题解决方法:在每个哲学家线程中输出其获得的筷子标号与时间(可以读取系统时间,或者自行设置时间标准),例如:哲学家2在第n秒获得筷子1,在第m秒获得筷子2。

实验报告要求:写明实验目的、实验设计步骤、实验结果、总结。

附录:windows线程基本操作以windows线程函数为例介绍线程基本操作,以下函数都必须包含windows.h头文。

如果想更深入地了解线程,请参见《c++编程艺术》等相关书籍。

线程创建函数:HANDLE CreateThread (LPSECURITY_ATTRIBUTES secAttr,SIZE_T stackSize,LPTHREAD_START_ROUTINE threadFunc,LPVOID param,DWORD flags,LPDWORD threadID);在此,secAttr是一个用来描述线程的安全属性的指针。

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

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

计算机与信息工程学院实验报告一、实验内容1.练习在shell环境下编译执行程序(注意:①在vi编辑器中编写名为sample.c的c语言源程序②用linux自带的编译器gcc编译程序,例如:gcc –o test sample.c③编译后生成名为test.out的可执行文件;④最后执行分析结果;命令为:./test)注意:linux自带的编译程序gcc的语法是:gcc –o 目标程序名源程序名,例如:gcc –o sample1 sample1.c,然后利用命令:./sample 来执行。

如果仅用“gcc 源程序名”,将会把任何名字的源程序都编译成名为a.out的目标程序,这样新编译的程序会覆盖原来的程序,所以最好给每个源程序都起个新目标程序名。

2.进程的创建仿照例子自己编写一段程序,使用系统调用fork()创建两个子进程。

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

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

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

3.分析程序实验内容要在给出的例子程序基础上,根据要求进行修改,对执行结果进行分析。

二、实验步骤1. 利用fork()创建一个小程序(1)编写程序#include <sys/types.h>main (){int i=5;pid_t pid;pid=fork();for(;i>0;i--){if (pid < 0)printf("error in fork!");else if (pid == 0)printf("i am the child process, my process id is %d and i=%d\n",getpid(),i);elseprintf("i am the parent process, my process id is %d and i=%d\n",getpid(),i);}for(i=5;i>0;i--){if (pid < 0)printf("error in fork!");else if (pid == 0)printf("the child process, my process id is %d and i=%d\n",getpid(),i);elseprintf("the parent process, my process id is %d andi=%d\n",getpid(),i);}}(2)运行程序(3)分析程序在这里,主程序先运行,在屏幕上输出一个a,之后两个子程序分别运行而输出c和b。

实验三 进程同步实验

实验三 进程同步实验

实验三进程同步机制一、实验内容:学习Windows有关进程/线程同步的背景知识和API,学习windows平台下常用的同步方式,并分析2个实验程序(利用信号量实现两个进程间的同步和利用互斥量实现读者写者问题),观察程序的运行情况并分析执行结果。

二、实验目的:在本实验中,通过对互斥量(Mutex)和信号量(Semaphore)对象的了解,来加深对Windows 进程、线程同步的理解。

(1) 了解互斥量和信号量对象。

(2) 通过分析实验程序,理解管理信号量对象的API。

(3) 理解在进程中如何使用信号量对象。

(4) 通过分析实验程序,理解在线程中如何使用互斥量对象。

(5) 理解父进程创建子进程的程序设计方法,理解在主线程中创建子线程的方法。

三、实验要求:(1) 理解Windows有关进程/线程同步的背景知识和API。

(2) 按要求运行2个程序,观察程序执行的结果,并给出要求的结果分析。

(3) 参照3-2程序,写出一个实现单个生产者—消费者问题的算法,可以使用单个缓冲区,也可以使用缓冲池,生产者随机产生任意形式的数据并放入缓冲区中,消费者则以随机的时间间隔从缓冲区中取数据,随机时间请使用随机数产生。

四、并发与同步的背景知识Windows开发人员可以使用同步对象来协调线程和进程的工作,以使其共享信息并执行任务。

此类对象包括互斥量Mutex、信号量Semaphore、事件Event等。

多进程、多线程编程中关键的一步是保护所有的共享资源,工具主要有互斥量Mutex 和信号量Semaphore等;另一个是协调线程使其完成应用程序的任务,为此,可利用内核中的信号量对象或事件对象。

互斥量是一个可命名且安全的内核对象,主要目的是引导对共享资源的访问。

拥有单一访问资源的线程创建互斥体,所有希望访问该资源的线程应该在实际执行操作之前获得互斥体,而在访问结束时立即释放互斥体,以允许下一个等待线程获得互斥体,然后接着进行下去。

操作系统实验报告——进程同步与互斥

操作系统实验报告——进程同步与互斥

操作系统实验报告——进程同步与互斥一、实验内容本实验主要内容是通过编写程序来实现进程的同步与互斥。

具体来说,是通过使用信号量来实现不同进程之间的同步和互斥。

我们将编写两个进程,一个进程负责打印奇数,另一个进程负责打印偶数,两个进程交替打印,要求打印的数字从1开始,直到100结束。

二、实验原理进程的同步是指多个进程之间按照一定的顺序执行,进程之间互相等待的关系。

而进程的互斥是指多个进程竞争同一个资源,需要通过其中一种方式来避免同时访问共享资源,以免造成数据错乱。

在本实验中,我们使用信号量来实现进程的同步与互斥。

信号量是一个计数器,用于表示一些共享资源的可用数量。

进程在访问共享资源时,需要先对信号量进行操作,当信号量大于0时,表示资源可用,进程可以访问;当信号量等于0时,表示资源不可用,进程需要等待。

进程同步的实现可以通过信号量的P操作与V操作来完成。

P操作用于申请资源,当资源可用时,将计数器减一,并进入临界区;V操作用于释放资源,当资源使用完毕时,将计数器加一,使等待资源的进程能够申请。

进程互斥的实现可以通过信号量的P操作与V操作结合临界区来完成。

当多个进程需要访问共享资源时,需要先进行P操作,进入临界区,访问完毕后进行V操作,离开临界区。

三、实验步骤1.首先,我们需要创建两个进程,一个进程负责打印奇数,另一个进程负责打印偶数。

2. 然后,我们创建一个共享变量count,用来记录打印的数字。

3. 接着,我们创建两个信号量odd和even,用来控制进程的同步与互斥。

odd信号量初始值为1,表示打印奇数的进程可以访问;even信号量初始值为0,表示打印偶数的进程需要等待。

4.编写奇数打印进程的代码,首先进行P操作,判断奇数信号量是否大于0,如果大于0,表示可以打印奇数。

5. 如果可以打印奇数,将count加一,并输出当前的奇数,然后进行V操作,释放偶数打印进程的等待。

6.同样的,编写偶数打印进程的代码,首先进行P操作,判断偶数信号量是否大于0,如果大于0,表示可以打印偶数。

进程的同步实验报告

进程的同步实验报告

进程的同步实验报告进程的同步实验报告引言:进程同步是操作系统中一个重要的概念,它涉及到多个进程之间的协调和合作。

在本次实验中,我们将通过一个简单的实例来探讨进程同步的概念和实现方式。

实验目的:通过实验,我们的目标是理解进程同步的概念,学习常见的同步机制,并通过编程实现一个简单的同步问题。

实验环境:本次实验使用了C语言作为编程语言,并在Linux操作系统上进行。

实验过程:我们的实验场景是一个餐厅,有一个厨师和多个服务员。

厨师负责烹饪菜品,服务员负责上菜给客人。

我们需要实现的是,服务员只有在厨师烹饪好一道菜之后才能上菜,否则需要等待。

首先,我们使用互斥锁来实现进程间的同步。

互斥锁是一种常见的同步机制,它可以确保在同一时间只有一个进程可以访问共享资源。

在我们的实验中,厨师和服务员都需要访问菜品资源,因此我们为菜品资源添加了一个互斥锁。

接下来,我们使用条件变量来实现进程间的等待和唤醒操作。

条件变量是一种同步机制,它可以让进程在某个条件满足时等待,直到被唤醒。

在我们的实验中,服务员需要等待厨师烹饪好菜品之后才能上菜,因此我们创建了一个条件变量,并在服务员的代码中使用了等待和唤醒操作。

实验结果:经过实验,我们成功地实现了进程间的同步。

在我们的实验场景中,厨师会不断地烹饪菜品,并在烹饪完成后通知服务员上菜。

服务员会等待厨师的通知,然后上菜给客人。

通过互斥锁和条件变量的使用,我们保证了服务员只会在厨师烹饪完成后才会上菜,避免了资源竞争和错误的上菜行为。

讨论与总结:通过本次实验,我们深入理解了进程同步的概念和实现方式。

互斥锁和条件变量是常见的同步机制,它们可以有效地解决进程间的竞争和协调问题。

在实际的操作系统中,进程同步是一个非常重要的概念,它保证了多个进程之间的正确执行和合作。

然而,进程同步也可能引发一些问题。

例如,如果互斥锁的使用不当,可能会导致死锁的发生。

死锁是一种进程无法继续执行的状态,它会导致系统的停滞。

进程同步:实验报告

进程同步:实验报告

1.实验内容(进程的同步)(1)阅读理解示例程序。

(2)说明示例程序是否能适合解决N个生产者和1个消费者问题,并设计实验验证(3) 参照教材修改为N个生产者和1个消费者问题(4) 思考N个生产者和M个消费者问题的解决方案(不要求)(5) 利用信号量解决同步问题。

2.实验目的通过程序模拟及验证生产者消费者问题等经典问题,深入理解并发中的同步和互斥的概念3.实验原理(1)进程概念:(1.定义:程序的一次执行过程(2.三种基本状态:就绪状态,执行状态,阻塞状态(2)进程同步:(1.定义:并发进程在执行次序上的协调,以达到有效的资源共享和相互合作,使程序执行有可再现性。

(2.两种形式的制约关系:(一:资源共享关系:进程间接制约,需互斥地访问临界资源。

)、(二:相互合作关系:进程直接制约)(3.临界资源:一次仅允许一个进程访问的资源,引起不可再现性是因为临界资源没有互斥访问。

(3)信号量:定义一个用于表示资源数目的整型量S,它与一般的整型量不同,除初始化外,仅能通过两个标准的原子操作wait(S)和signal(S)来访问,俗称P,V操作。

通俗来讲就是用P来访问资源后减去一个单位资源,用V操作来释放一个单位资源就是现有资源上加一个单位资源。

4.实验内容一:说明示例程序是否能适合解决N个生产者和1个消费者问题,并设计实验验证答:示例程序不能解决多个生产者和消费者的问题,它是解决单个消费者和生产者的。

如果可以就要修改代码,如“二”所说。

二:多个消费者和生产者的问题如上图所示:如果要解决多个生产者和消费者的问题:第一步:分析上图得出了两种关系,分别是异步和同步的关系第二步:异步关系的是生产者和生产者之间的,因为同一时刻只能有一个生产者访问缓冲区,所以我们就可以设置临界资源.获得临界资源的生产者才能把产品放到缓冲区里第三步:同步关系有两个,首先是生产者和缓冲区之间,再是缓冲区和消费者之间。

他们都满足一前一后的关系,即当缓冲区空间未满时,生产者才可以放产品;缓冲区不为空的时候才可以让消费者取出产品消费。

操作系统-进程管理与进程同步-实验报告

操作系统-进程管理与进程同步-实验报告

实验一、进程管理与进程同步一、实验目的了解进程管理的实现方法,理解和掌握处理进程同步问题的方法。

二、实验内容实现银行家算法、进程调度过程的模拟、读者-写者问题的写者优先算法。

实验步骤:理解安全性算法和银行家算法的核心机制:针对3类资源、5个进程的情况,设计相应的数据结构,分别表示每个进程占用各类资源的情况;编程实现安全性算法函数,编制主函数,动态输入资源的占用情况,进程的资源申请,调用安全性函数,实现银行家算法;测试:输入可分配和不可分配的请求,测试系统的正确性。

三、实验环境Windows 2000;Microsoft Visual C++ 6.0四、程序源码与运行结果银行家算法代码:#include "malloc.h"#include "stdio.h"#include "stdlib.h"#define alloclen sizeof(struct allocation)#define maxlen sizeof(struct max)#define avalen sizeof(struct available)#define needlen sizeof(struct need)#define finilen sizeof(struct finish)#define pathlen sizeof(struct path)struct allocation{int value;struct allocation *next;};struct max{int value;struct max *next;};struct available /*可用资源数*/{int value;struct available *next;};struct need /*需求资源数*/{int value;struct need *next;};struct path{int value;struct path *next;};struct finish{int stat;struct finish *next;};int main(){int row,colum,status=0,i,j,t,temp,processtest;struct allocation *allochead,*alloc1,*alloc2,*alloctemp;struct max *maxhead,*maxium1,*maxium2,*maxtemp;struct available *avahead,*available1,*available2,*workhead,*work1,*work2,*worktemp,*worktemp1; struct need *needhead,*need1,*need2,*needtemp;struct finish *finihead,*finish1,*finish2,*finishtemp;struct path *pathhead,*path1,*path2;printf("\n请输入系统资源的种类数:");scanf("%d",&colum);printf("请输入现时内存中的进程数:");scanf("%d",&row);printf("请输入已分配资源矩阵:\n");for(i=0;i<row;i++){for (j=0;j<colum;j++){printf("请输入已分配给进程 p%d 的 %c 种系统资源:",i,'A'+j);if(status==0){allochead=alloc1=alloc2=(struct allocation*)malloc(alloclen);alloc1->next=alloc2->next=NULL;scanf("%d",&allochead->value);status++;}else{alloc2=(struct allocation *)malloc(alloclen);scanf("%d,%d",&alloc2->value);if(status==1){allochead->next=alloc2;status++;}alloc1->next=alloc2;alloc1=alloc2;}}}alloc2->next=NULL;status=0;printf("请输入最大需求矩阵:\n");for(i=0;i<row;i++){for (j=0;j<colum;j++){printf("请输入进程 p%d 种类 %c 系统资源最大需求:",i,'A'+j);if(status==0){maxhead=maxium1=maxium2=(struct max*)malloc(maxlen);maxium1->next=maxium2->next=NULL;scanf("%d",&maxium1->value);status++;}else{maxium2=(struct max *)malloc(maxlen);scanf("%d,%d",&maxium2->value);if(status==1){maxhead->next=maxium2;status++;}maxium1->next=maxium2;maxium1=maxium2;}}}maxium2->next=NULL;status=0;printf("请输入现时系统剩余的资源矩阵:\n");for (j=0;j<colum;j++){printf("种类 %c 的系统资源剩余:",'A'+j);if(status==0){avahead=available1=available2=(struct available*)malloc(avalen); workhead=work1=work2=(struct available*)malloc(avalen);available1->next=available2->next=NULL;work1->next=work2->next=NULL;scanf("%d",&available1->value);work1->value=available1->value;status++;}else{available2=(struct available*)malloc(avalen);work2=(struct available*)malloc(avalen);scanf("%d,%d",&available2->value);work2->value=available2->value;if(status==1){avahead->next=available2;workhead->next=work2;status++;}available1->next=available2;available1=available2;work1->next=work2;work1=work2;}}available2->next=NULL;work2->next=NULL;status=0;alloctemp=allochead;maxtemp=maxhead;for(i=0;i<row;i++)for (j=0;j<colum;j++){if(status==0){needhead=need1=need2=(struct need*)malloc(needlen); need1->next=need2->next=NULL;need1->value=maxtemp->value-alloctemp->value;status++;}else{need2=(struct need *)malloc(needlen);need2->value=(maxtemp->value)-(alloctemp->value); if(status==1)needhead->next=need2;status++;}need1->next=need2;need1=need2;}maxtemp=maxtemp->next;alloctemp=alloctemp->next;}need2->next=NULL;status=0;for(i=0;i<row;i++){if(status==0){finihead=finish1=finish2=(struct finish*)malloc(finilen); finish1->next=finish2->next=NULL;finish1->stat=0;status++;}else{finish2=(struct finish*)malloc(finilen);finish2->stat=0;if(status==1){finihead->next=finish2;status++;}finish1->next=finish2;finish1=finish2;}}finish2->next=NULL; /*Initialization compleated*/status=0;processtest=0;for(temp=0;temp<row;temp++){alloctemp=allochead;needtemp=needhead;finishtemp=finihead;worktemp=workhead;for(i=0;i<row;i++)worktemp1=worktemp;if(finishtemp->stat==0){for(j=0;j<colum;j++,needtemp=needtemp->next,worktemp=worktemp->next) if(needtemp->value<=worktemp->value)processtest++;if(processtest==colum){for(j=0;j<colum;j++){worktemp1->value+=alloctemp->value;worktemp1=worktemp1->next;alloctemp=alloctemp->next;}if(status==0){pathhead=path1=path2=(struct path*)malloc(pathlen);path1->next=path2->next=NULL;path1->value=i;status++;}else{path2=(struct path*)malloc(pathlen);path2->value=i;if(status==1){pathhead->next=path2;status++;}path1->next=path2;path1=path2;}finishtemp->stat=1;}else{for(t=0;t<colum;t++)alloctemp=alloctemp->next;finishtemp->stat=0;}}elsefor(t=0;t<colum;t++){needtemp=needtemp->next;alloctemp=alloctemp->next;}processtest=0;worktemp=workhead;finishtemp=finishtemp->next;}}path2->next=NULL;finishtemp=finihead;for(temp=0;temp<row;temp++){if(finishtemp->stat==0){printf("\n系统处于非安全状态!\n"); exit(0);}finishtemp=finishtemp->next;}printf("\n系统处于安全状态.\n"); printf("\n安全序列为: \n");do{printf("p%d ",pathhead->value);}while(pathhead=pathhead->next);printf("\n");return 0;}运行结果:备注:输入数据为P110 银行家算法之例所用数据《计算机操作系统》(第三版)西安电子科技大学出版社银行家算法原理说明:银行家算法是一种最有代表性的避免死锁的算法。

进程同步实验报告

进程同步实验报告

实验三进程的同步一、实验目的1、了解进程同步和互斥的概念及实现方法;2、更深一步的了解fork()的系统调用方式。

二、实验内容1、预习操作系统进程同步的概念及实现方法。

2、编写一段源程序,用系统调用fork()创建两个子进程,当此程序运行时,在系统中有一个父进程和两个子进程活动。

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

程序的输出是什么?分析原因。

3、阅读模拟火车站售票系统和实现进程的管道通信源代码,查阅有关进程创建、进程互斥、进程同步的系统功能调用或API,简要解释例程中用到的系统功能或API的用法,并编辑、编译、运行程序,记录程序的运行结果,尝试给出合理的解释。

4、(选做)修改问题2的代码,使得父子按顺序显示字符“a”;“b”、“c”编辑、编译、运行。

记录程序运行结果。

三、设计思想1、程序框架(1)创建两个子进程:(2)售票系统:(3)管道通信:先创建子进程,然后对内容加锁,将输出语句存入缓存,并让子进程自己进入睡眠,等待别的进程将其唤醒,最后解锁;第二个子进程也执行这样的过程。

父进程等待子进程后读内容并输出。

(4)修改程序(1):在子进程的输出语句前加上sleep()语句,即等待父进程执行完以后再输出。

2、用到的文件系统调用函数(1)创建两个子进程:fork()(2)售票系统:DWORD WINAPI Fun1Proc(LPVOID lpPartameter);CreateThread(NULL,0,Fun1Proc,NULL,0,NULL);CloseHandle(hThread1);(HANDLE)CreateMutex(NULL,FALSE,NULL);Sleep(4000)(sleep调用进程进入睡眠状态(封锁), 直到被唤醒);WaitForSingleObject(hMutex,INFINITE);ReleaseMutex(hMutex);(3)管道通信:pipe(fd),fd: int fd[2],其中: fd[0] 、fd[1]文件描述符(读、写);lockf( fd,function,byte)(fd: 文件描述符;function: 1: 锁定 0:解锁;byte: 锁定的字节数,0: 从当前位置到文件尾);write(fd,buf,byte)、read(fd,buf,byte) (fd: 文件描述符;buf : 信息传送的源(目标)地址;byte: 传送的字节数);sleep(5);exit(0);read(fd[0],s,50)(4)修改程序(1):fork(); sleep();四、调试过程1、测试数据设计(1)创建两个子进程:运行结果:(2)售票系统:运行结果:(3)管道通信:运行结果:(4)修改程序(1):2、测试结果分析 (1)调用fork()创建一个子进程,当运行到第一个子进程输出了b ,当父进程运行时创建另一个子进程。

操作系统实验报告——进程同步与互斥

操作系统实验报告——进程同步与互斥

《进程同步与互斥》实验报告实验序号:01 实验项目名称:进程同步与互斥学号姓名专业、班实验地点指导教师时间一、实验目的1、掌握基本的进程同步与互斥算法,理解生产者-消费者问题。

2、学习使用Windows 2000/XP中基本的同步对象,掌握相关API的使用方法。

3、了解Windows 2000/XP中多线程的并发执行机制,实现进程的同步与互斥。

4、设计程序,实现生产者-消费者进程(线程)的同步与互斥;二、实验环境Windows 2000/XP + Visual C++ 6.0三、实验内容以生产者-消费者模型为依据,在Windows 2000/XP环境下创建一个控制台进程,在该进程中创建n个线程模拟生产者和消费者,实现进程(线程)的同步与互斥。

四、设计思路和流程框图生产者进程的功能:生产东西,供消费者消费;消费者进程的功能:消费生产者生产的东西。

生产者生产产品并存入缓冲区供消费者取走使用,消费者从缓冲器内取出产品去消费。

在生产者和消费者同时工作时,必须禁止生产者将产品放入已装满的缓冲器内,禁止消费者从空缓冲器内取产品。

五、源程序(含注释)清单#include<windows.h>printf("Consumer %2d finish consuming product %2d\n ",m_serial,m_thread_request[i]);}//离开临界区LeaveCriticalSection(&PC_Critical[BufferPos]);}}六、测试结果以及实验总结1、通过实验进一步了解了基本的进程同步与互斥算法,理解生产者-消费者问题2、掌握了相关API的使用方法。

3、了解到进程是一个可以拥有资源的基本单位,是一个可以独立调度和分派的基本单位。

而线程是进程中的一个实体,是被系统独立调度和分配的基本单位,故又称为轻权(轻型)进程(Light Weight Process)。

操作系统实验报告实验3_1

操作系统实验报告实验3_1

操作系统实验报告实验3_1一、实验目的本次实验的主要目的是深入理解操作系统中进程管理的相关概念和原理,通过实际操作和观察,掌握进程的创建、调度、同步与互斥等关键机制,提高对操作系统内核工作原理的认知和实践能力。

二、实验环境本次实验在装有 Windows 10 操作系统的计算机上进行,使用了Visual Studio 2019 作为开发工具,编程语言为 C++。

三、实验内容与步骤(一)进程创建1、编写一个简单的 C++程序,使用系统调用创建一个新的进程。

2、在父进程和子进程中分别输出不同的信息,以区分它们的执行逻辑。

```cppinclude <iostream>include <windowsh>int main(){DWORD pid;HANDLE hProcess = CreateProcess(NULL, "childexe", NULL, NULL, FALSE, 0, NULL, NULL, NULL, &pid);if (hProcess!= NULL) {std::cout <<"Parent process: Created child process with PID "<< pid << std::endl;WaitForSingleObject(hProcess, INFINITE);CloseHandle(hProcess);} else {std::cerr <<"Failed to create child process" << std::endl;return 1;}return 0;}```(二)进程调度1、设计一个多进程并发执行的程序,通过设置不同的优先级,观察操作系统对进程的调度情况。

2、记录每个进程的执行时间和等待时间,分析调度算法的效果。

```cppinclude <iostream>include <windowsh>DWORD WINAPI ProcessFunction(LPVOID lpParam) {int priority =(int)lpParam;DWORD start = GetTickCount();std::cout <<"Process with priority "<< priority <<"started" << std::endl;for (int i = 0; i < 100000000; i++){//执行一些计算操作}DWORD end = GetTickCount();DWORD executionTime = end start;std::cout <<"Process with priority "<< priority <<" ended Execution time: "<< executionTime <<" ms" << std::endl;return 0;}int main(){HANDLE hThread1, hThread2;int priority1 = 1, priority2 = 2;hThread1 = CreateThread(NULL, 0, ProcessFunction, &priority1, 0, NULL);hThread2 = CreateThread(NULL, 0, ProcessFunction, &priority2, 0, NULL);if (hThread1!= NULL && hThread2!= NULL) {SetThreadPriority(hThread1, THREAD_PRIORITY_LOWEST);SetThreadPriority(hThread2, THREAD_PRIORITY_NORMAL);WaitForSingleObject(hThread1, INFINITE);WaitForSingleObject(hThread2, INFINITE);CloseHandle(hThread1);CloseHandle(hThread2);} else {std::cerr <<"Failed to create threads" << std::endl;return 1;}return 0;}```(三)进程同步与互斥1、实现一个生产者消费者问题的程序,使用信号量来实现进程之间的同步与互斥。

进程并发实验报告

进程并发实验报告

一、实验背景与目的随着计算机技术的发展,多任务处理和多进程并发已经成为操作系统设计中的基本要求。

为了更好地理解进程并发的基本原理和实现方法,我们进行了本次实验。

实验的目的是通过实践操作,加深对进程并发执行的理解,掌握进程创建、同步、互斥等基本概念,并学会使用相关系统调用实现进程的并发控制。

二、实验环境与工具实验环境:Windows 10操作系统,Visual Studio 2019开发环境。

实验工具:C++编程语言,WinAPI系统调用。

三、实验内容与步骤本次实验主要分为以下几个部分:1. 进程创建与并发执行- 使用CreateProcess函数创建多个进程,并观察它们的并发执行情况。

- 使用GetTickCount函数获取每个进程的执行时间,分析并发执行的效果。

2. 进程同步- 使用互斥锁(mutex)实现进程间的同步,确保同一时刻只有一个进程访问共享资源。

- 使用条件变量(condition variable)实现进程间的条件同步,实现生产者-消费者模型。

3. 进程互斥- 使用信号量(semaphore)实现进程间的互斥,避免资源竞争。

- 使用临界区(critical section)保护共享资源,防止多个进程同时访问。

4. 实验分析- 分析实验结果,总结进程并发、同步和互斥的原理和方法。

- 讨论实验中遇到的问题和解决方法。

四、实验代码示例以下是一个简单的实验代码示例,演示了使用互斥锁实现进程同步的过程:```cpp#include <windows.h>#include <iostream>using namespace std;// 全局互斥锁mutex mtx;void processFunction(){unique_lock<mutex> lock(mtx);cout << "Process " << GetCurrentProcessId() << " is running." << endl;lock.unlock();}int main(){// 创建两个进程CreateProcess(NULL, "process.exe", NULL, NULL, FALSE, 0, NULL, NULL, NULL, NULL);// 主进程继续执行cout << "Main process is running." << endl;return 0;}```五、实验结果与分析1. 进程创建与并发执行通过实验,我们观察到多个进程可以并发执行,并且每个进程的执行时间都会有所不同。

实验3_进程并发与同步

实验3_进程并发与同步
}
请根据程序运行结果,画出进程家族树,并分析原因。
3、修改程序1,在父、子进程中分别使用wait、exit等系统调用“实现”其同步推进,父进程必须等待儿子进程与女儿进程结束,才可以输出消息。写出相应的同步控制,并分析运行结果。
4、创建一个子进程,并给它加载程序,其功能是调用键盘命令“ls -l”,已知该键盘命令的路径与文件名为:/bin/ls。父进程创建子进程,并加载./child2程序。写出相应的程序代码并分析程序运行结果。
2父进程返回后用第二个fork创建子进程4用第四个fork创建子进程53子进程2返回后用第二个fork建子进程7用第四个fork创建子进程84子进程返回后用第三个fork创建子进程9用第四个fork创建子进程10
课程实验报告
课程名称
计算机操作系统
班级
计算121
实验日期
2015.4.16
姓名
潘洪菊
学号
else
{
wait(0);
exit(0);
}
return 0;
}




操作系统:Win7 32位
虚拟机:Vmware9.0
Linux系统:ubuntu11.10
开发环境:vi编辑器,gcc编译器,gdb调试器




1、编写一C语言程序,实现在程序运行时通过系统调用fork( )创建两个子进程,使父、子三进程并发执行,父亲进程执行时屏幕显示“I am father”,儿子进程执行时屏幕显示“I am son”,女儿进程执行时屏幕显示“I am daughter”。
else
printf("I am father.\n");

操作系统实验3进程同步报告

操作系统实验3进程同步报告

实验三进程同步一、实验目的:1.了解进程和线程的同步方法,学会运用进程和线程同步方法来解决实际问题;2.了解windows系统下Win32 API或Pthread信号量机制的使用方法;二、实验预备内容:1.对书上所说基于信号量的有限缓冲的生产者-消费者问题;2.对于信号量的概念有大概的了解,知道如何用信号量的wiat()和signal()函数如何取消应用程序进入临界区的忙等;三、实验环境说明:此实验在Win7(32位) CodeBlocks环境下实现,采用WinAPI的信号量机制。

四、实验内容:设计一个程序解决有限缓冲问题,其中的生产者与消费者进程如下图所示。

在Bounded-Buffer Problem(6.6.1节)中使用了三个信号量:empty (记录有多少空位)、full(记录有多少满位)以及mutex(二进制信号量或互斥信号量,以保护对缓冲区插入与删除的操作)。

对于本项目,empty和full将采用标准计数信号量,而mutex将采用二进制信号量。

生产者与消费者作为独立线程,在empty、full、mutex的同步前提下,对缓冲区进行插入与删除。

本项目可采用Pthread或Win32 API。

(本实验采用Win32 API)五、程序设计说明:1.全局变量:定义缓冲区数组及其环形队列表达方式,定义mutex、empty、full 三个信号量。

empty记录缓冲区有多少个空位;full记录缓冲区有多少个满位;mutex作为互斥信号量,保护对缓冲区插入或删除的操作。

具体定义如下:定义生产者、消费者线程结构和包含的信息:(由于题目中没有要求,因此只定义了编号一个变量)2.缓冲区:缓冲区是一个元数据类型为buffer_item(可通过typedef定义)的固定大小的数组,按环形队列处理。

buffer_item的定义及缓冲区大小可保存在头文件中:A.insert_item():先判断缓冲区是否已满,不满则向缓冲区中插入元素;B.remove_item()先判断缓冲区是否为空,不空则从缓冲区中删除元素;3.生产者线程:生产者线程交替执行如下两个阶段:睡眠一段随机事件,向缓冲中插入一个随机数。

实验三_进程的同步

实验三_进程的同步

进程的同步实验性质:验证+设计建议学时:2学时一、实验目的●使用EOS的信号量编程解决生产者—消费者问题,理解进程同步的意义。

●调试跟踪EOS的信号量的工作过程,理解进程同步的原理。

●修改EOS的信号量算法,使之支持等待超时唤醒功能(有限等待),加深理解进程同步的原理。

二、预备知识阅读《EOS实验指南》5.3节,学习EOS内核提供的三种同步对象(该实验没有涉及到Event 同步对象),重点理解各种同步对象的状态与使用方式。

了解经典的生产者与消费者同步的问题。

阅读《EOS实验指南》5.2节,学习在EOS应用程序中调用EOS API函数CreateThread创建线程的方法。

三、实验内容3.1 准备实验按照下面的步骤准备本次实验:1.启动OS Lab。

2.新建一个EOS Kernel项目。

3.分别使用Debug配置和Release配置生成此项目,从而在该项目文件夹中生成完全版本的EOS SDK文件夹。

4.新建一个EOS应用程序项目。

5.使用在第3步生成的SDK文件夹覆盖EOS应用程序项目文件夹中的SDK文件夹。

3.2 使用EOS的信号量解决生产者-消费者问题在本实验文件夹中提供了使用EOS的信号量解决生产者-消费者问题的参考源代码文件pc.c,使用OS Lab打开此文件(将文件拖动到OS Lab窗口中释放即可打开),仔细阅读此文件中的源代码和注释,各个函数的流程图可以参见图1。

思考在两个线程函数中哪些是临界资源?哪些代码是临界区?哪些代码是进入临界区?哪些代码是退出临界区?进入临界区和退出临界区的代码是否成对出现?按照下面的步骤查看生产者-消费者同步执行的过程:1.使用pc.c文件中的源代码替换之前创建的EOS应用程序项目中的EOSApp.c文件内的源代码。

2.按F7生成修改后的EOS应用程序项目。

3.按F5启动调试。

OS Lab会首先弹出一个调试异常对话框。

4.在调试异常对话框中选择“否”,继续执行。

实验三 进程同步实验

实验三 进程同步实验

实验三进程同步实验实验三进程同步实验实验三:进程同步实验实验学时:3学时一、实验目的1、掌控操作系统的进程同步原理2、熟识linux的进程同步原语3、设计程序,同时实现经典进程同步问题二、实验基本原理1、在计算机操作系统中,pv操作是进程管理中的难点。

首先应当弄清楚pv操作方式的含义:pv操作方式由p操作方式原语和v操作方式原语共同组成(原语就是不容中断的过程),对信号量展开操作方式,具体内容定义如下:p(s):①将信号量s的值减至1,即s=s?1;②如果s?0,则该进程继续执行;否则该进程置为等待状态,排入等待队列。

v(s):①将信号量s的值加1,即s=s+1;②如果s>0,则该进程继续执行;否则释放出来队列中第一个等候信号量的进程。

pv操作的意义:我们用信号量及pv操作来实现进程的同步和互斥。

pv操作属于进程的低级通信。

什么就是信号量?信号量(semaphore)的数据结构为一个值和一个指针,指针指向等候该信号量的之下一个进程。

信号量的值与适当资源的采用情况有关。

当它的值大于0时,则表示当前需用资源的数量;当它的值大于0时,其绝对值则表示等候采用该资源的进程个数。

特别注意,信号量的值仅能够由pv操作方式去发生改变。

一般来说,信号量s?0时,s表示可用资源的数量。

执行一次p操作意味着请求分配一个单位资源,因此s的值减1;当s<0时,表示已经没有可用资源,请求者必须等待别的进程释放该类资源,它才能运行下去。

而执行一个v操作意味着释放一个单位资源,因此s的值加1;若s?0,表示有某些进程正在等待该资源,因此要唤醒一个等待状态的进程,使之运行下去。

2、linux的进程同步原语(1)wait();阻塞父进程,子进程执行(2)#include#includekey_tftok(char*pathname,charproj);它返回与路径pathname相对应的一个键值。

(3)intsemget(key_tkey,intnsems,intsemflg)参数key是一个键值,由ftok获得,唯一标识一个信号灯集,用法与msgget()中的key相同;参数nsems指定打开或者新创建的信号灯集中将包含信号灯的数目;semflg参数是一些标志位。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
{
wait(0);
wait(0);
printf("I am father.\n");
}
}
return 0;
}
4.
#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>
int main()
{
execl("/bin/ls -1","ls","-1",NULL);
exit(0);
return 0;
}
#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>
#include<sys/wait.h>
int main()
{
int p;
while((p=fork())==-1);
if(p==0)
execl("./child","ls","-1",NULL);
else
{
wait(0);
exit(0);
}
return 0;
}
建子进程7,用第四个fork()创建子进程8。
4)子进程3返回后用第三个fork()创建子进程9,用第四个fork()
创建子进程10。
5)子进程4返回后用第四个fork()创建子进程11。
6)子进程6返回后用用第三个fork()创建子进程12,用第四个fork
()创建子进程13。
7)子进程7返回后用第四个fork()创建子进程14。
2.
1
5
3
4
2
9
8
7
6
10 11
12 13 14 15
16
1)父进程1用第一个fork()创建子进程2;
2)父进程返回后用第二个fork()创建子进程3,用第三个fork( )创建
子进程4,用第四个fork()创建子进程5。
3)子进程2返回后用第二个fork()创建子进程6,用第三个fork( )创
else
printf("I am father.\n");
}
return 0;
}
2.#include <stdio.h>
main()
{
fork();
fork();
fork();
fork();
printf("A\n");
}
3.#include<stdio.h>
#include<stdlib.h>
int main()









1.
该程序多次运行后,输出的结果可能会是:儿子女儿父亲;女儿父亲儿子;女儿儿子父亲等随机结果中的任意一种。每次运行后都会产生父子3个进程,所以会有3条语句输出。其中系统提示符[phj@phj-virtual:~ /hello$显示会跟随在父进程输出语句之后。
下图为显示的不同顺序的一种。


1.#include<stdio.h>
int main()
{
int ps,pd;
while((ps=fork())==-1);
if(ps==0)
printf("I am daughter.\n");
else
{
while((pd=fork())==-1);
if(pd==0)
printf("I am son.\n");
{
int ps,pd;
while((ps=fork())==-1);
if(ps==0)
{
printf("I am son.\n");
exit(0);
}
else
{
while((pd=fork())==-1);
if(pd==0)
{
printf("I am daughter.\n");
exit(0);
}
else
课程实验报告
课程名称
计算机操作系统
班级
计算121
实验日期
2015.4.16
姓名
潘洪菊
学号
201207003
实验成绩
实验名称
实验3进程并发与同步


目的及要来自求1、加深对进程概念的理解,区分进程并发执行与串行执行;
2、掌握进程并发执行的原理,理解进程并发执行的特点;
3、了解fork( )系统调用的返回值,掌握用fork()创建进程的方法;
}
请根据程序运行结果,画出进程家族树,并分析原因。
3、修改程序1,在父、子进程中分别使用wait、exit等系统调用“实现”其同步推进,父进程必须等待儿子进程与女儿进程结束,才可以输出消息。写出相应的同步控制,并分析运行结果。
4、创建一个子进程,并给它加载程序,其功能是调用键盘命令“ls -l”,已知该键盘命令的路径与文件名为:/bin/ls。父进程创建子进程,并加载./child2程序。写出相应的程序代码并分析程序运行结果。
要求多次连续反复运行这个程序,观察屏幕显示结果的顺序,直至出现不一样的情况为止。要求有运行结果截图与结果分析
2、连续4个fork()的进程家族树,family1-1.c程序清单如下:
#include <stdio.h>
main()
{
fork();
fork();
fork();
fork();
printf(“A\n”);
熟悉wait、exit等系统调用;
4、能利用相应的系统调用实现进程树与进程间的同步。




操作系统:Win7 32位
虚拟机:Vmware9.0
Linux系统:ubuntu11.10
开发环境:vi编辑器,gcc编译器,gdb调试器




1、编写一C语言程序,实现在程序运行时通过系统调用fork( )创建两个子进程,使父、子三进程并发执行,父亲进程执行时屏幕显示“I am father”,儿子进程执行时屏幕显示“I am son”,女儿进程执行时屏幕显示“I am daughter”。
8)子进程9返回后用第四个fork()创建子进程13。
9)子进程6返回后用第四个fork()创建子进程15。
10)子进程12返回后用第四个fork()创建子进程16。
3.
.
父进程通过执行两次wait()系统调用,等待子进程结束后再输出消息。
4.


在进行实验的时候可能会出现进程输出信息一直一样的情况,需要多次执行输出才有可能会看到输出结果不一样的情况;
相关文档
最新文档