实验三进程同步实验

合集下载

实验三进程同步

集美大学诚毅学院信息工程系实验报告课程名称计算机操作系统序号名称实验三进程同步姓名孙幸杰学号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．实验内容(进程的同步)(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 个消费者问题，并设计实验验证答：⽰例程序不能解决多个⽣产者和消费者的问题，它是解决单个消费者和⽣产者的。

如果可以就要修改代码，如“⼆”所说。

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

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

实验三进程通讯实验报告【姓名】【学号】【实验题目】进程通讯——消息队列与共享存储区【实验目的】（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值，故循环等待。

16207318邓嘉操作系统实验三

操作系统实验第三次实验进程同步实验指导老师：***学号：********姓名：***操作系统第三次实验进程同步实验指导老师：谭朋柳学生：16207318邓嘉4.1 实验目的加深对并发协作进程同步与互斥概念的理解，观察和体验并发进程同步与互斥操作的效果，分析与研究经典进程同步与互斥问题的实际解决方案。

了解Linux 系统中IPC 进程同步工具的用法，练习并发协作进程的同步与互斥操作的编程与调试技术。

4.2 实验说明在linux 系统中可以利用进程间通信（interprocess communication ）IPC 中的3 个对象：共享内存、信号灯数组、消息队列，来解决协作并发进程间的同步与互斥的问题。

1）共享内存是OS 内核为并发进程间交换数据而提供的一块内存区（段）。

如果段的权限设置恰当，每个要访问该段内存的进程都可以把它映射到自己私有的地址空间中。

如果一进程更新了段中数据，那么其他进程立即会看到这一更新。

进程创建的段也可由另一进程读写。

linux 中可用命令ipcs -m 观察共享内存情况。

$ ipcs -m------ Shared Memory Segments --------key shmid owner perms bytes nattch status 0x00000000 327682 student 600 393216 2 dest0x00000000 360451 student 600 196608 2 dest 0x00000000 393220 student 600 196608 2 destkey 共享内存关键值shmid 共享内存标识owner 共享内存所由者（本例为student）perm 共享内存使用权限(本例为student 可读可写）byte 共享内存字节数nattch 共享内存使用计数status 共享内存状态上例说明系统当前已由student 建立了一些共享内存,每个都有两个进程在共享。

操作系统实验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.生产者线程：生产者线程交替执行如下两个阶段：睡眠一段随机事件，向缓冲中插入一个随机数。

操作系统实验三实验报告

三、实验内容
（一）进程创建
编写程序实现创建多个进程，并观察进程的执行情况。通过调用Windows API函数｀CreateProcess`来创建新的进程。在创建进程时，设置不同的参数，如进程的优先级、命令行参数等，观察这些参数对进程执行的影响。
（二）进程控制
实现对进程的暂停、恢复和终止操作。使用｀SuspendThread`和｀ResumeThread`函数来暂停和恢复进程中的线程，使用｀TerminateProcess`函数来终止进程。通过控制进程的执行状态，观察系统的资源使用情况和进程的响应。
（一）进程创建实验结果与分析
创建多个进程后，通过任务管理器观察到新创建的进程在系统中运行。不同的进程优先级设置对进程的CPU占用和响应时间产生了明显的影响。高优先级的进程能够更快地获得CPU资源，执行速度相对较快；而低优先级的进程则在CPU资源竞争中处于劣势，可能会出现短暂的卡顿或计一个多进程同步的程序，使用信号量、互斥量等同步机制来协调多个进程的执行。例如，实现一个生产者消费者问题，多个生产者进程和消费者进程通过共享缓冲区进行数据交换，使用同步机制来保证数据的一致性和正确性。
四、实验步骤
（一）进程创建实验步骤
1、打开Visual Studio 2019，创建一个新的C+＋控制台应用程序项目。
六、实验中遇到的问题及解决方法
（一）进程创建失败
在创建进程时，可能会由于参数设置不正确或系统资源不足等原因导致创建失败。通过仔细检查参数的设置，确保命令行参数、环境变量等的正确性，并释放不必要的系统资源，解决了创建失败的问题。
（二）线程控制异常
在暂停和恢复线程时，可能会出现线程状态不一致或死锁等异常情况。通过合理的线程同步和错误处理机制，避免了这些异常的发生。在代码中添加了对线程状态的判断和异常处理的代码，保证了线程控制的稳定性和可靠性。

实验三进程同步实验讲解

实验三进程同步机制一、实验内容:学习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等；另一个是协调线程使其完成应用程序的任务，为此，可利用内核中的信号量对象或事件对象。

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

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

课程设计3-进程同步模拟实现

课程设计生产者消费者问题生产者-消费者问题是一个经典的进程同步问题，该问题最早由Dijkstra提出，用以演示他提出的信号量机制。

在同一个进程地址空间内执行的两个进程，生产者进程生产物品，然后将物品放置在一个空缓冲区中供消费者进程消费；消费者进程从缓冲区中获得物品，然后释放缓冲区。

当生产者进程生产物品时，如果没有空缓冲区可用，那么生产者进程必须等待消费者进程释放出一个空缓冲区。

当消费者进程消费物品时，如果没有满的缓冲区，那么消费者进程将被阻塞，直到新的物品被生产出来。

一、课程设计目标学习进程间通信机制，使用信号量和共享内存实现经典进程同步问题“生产者-消费者”问题。

具体要求：1.创建信号量集，实现同步互斥信号量。

2.创建共享内存，模拟存放产品的公共缓冲池。

3.创建并发进程，实现进程对共享缓冲池的并发操作。

二、课题内容1．实验目的（1）掌握基本的同步互斥算法，理解生产者和消费者同步的问题模型。

（2）了解多进程的并发执行机制，进程间的同步和互斥。

2、实验环境：C/C++语言编译器，或Java3、实验要求（1）创建生产者和消费者线程创建一个控制台进程，在此进程中创建n个线程来模拟生产者或者消费者。

这些线程的信息由本程序定义的“测试用例文件”中予以指定。

（2）生产和消费的规则在按照上述要求创建线程进行相应的读写操作时，还需要符合以下要求：①共享缓冲区存在空闲空间时，生产者即可使用共享缓冲区。

②从上边的测试数据文件例子可以看出，某一生产者生产一个产品后，可能不止一个消费者，或者一个消费者多次地请求消费该产品。

此时，只有当所有的消费需求都被满足以后，该产品所在的共享缓冲区才可以被释放，并作为空闲空间允许新的生产者使用。

③每个消费者线程的各个消费需求之间存在先后顺序。

例上述测试用例文件包含一行信息“5 C 3 l 2 4”，可知这代表一个消费者线程，该线程请求消费1，2，4号生产者线程生产的产品。

而这种消费是有严格顺序的，消费1号线程产品的请求得到满足后才能继续往下请求2号生产者线程的产品。

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

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

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

我们将编写两个进程，一个进程负责打印奇数，另一个进程负责打印偶数，两个进程交替打印，要求打印的数字从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操作系统上进行。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

实验三_进程的同步

进程的同步实验性质：验证＋设计建议学时：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.在调试异常对话框中选择“否”，继续执行。

进程互斥与进程同步实验

· · · · · · · · · · · · · · · · · · · · · · · · · · sem_wait(&s_sem); /*对信号量的 P 操作*/ 临界区语句； sem_post(&full_sem); /*对信号量的 V 操作*/ · · · · · · · · · · · · · · · · · · · · · · · · · · 实例：一般情况下的生产者消费者问题程序名：ProducerConsumer.c 程序正文：可分两种情况（1） Linux 版本 /*多个生产者多个消费者多个缓冲区*/ #include <stdio.h> #include <stdlib.h> # include <unistd.h>*/ #include <pthread.h> #include <semaphore.h> #define M 10 /* 缓冲区数目*/ #define #define NP 6 /*生产者数目*/ NC 4 /*消费者数目*/
1 POSIX 线程编程基础
POSIX 线程模型中创建线程使用 pthread_t 变量，其步骤为：声明：pthread_t a_thread; 创建：使用函数
int pthread_create(pthread_t *p, const pthread_attr_t *attr, void *(*start_rtn)(void),void *arg);
返回值: 如果正常创建，返回 0；否则返回一个非零的值。第一个参数：pthread_t 变量（线程变量）的名字；第二个参数：设置线程属性。第三个参数：线程运行函数的起始地址（即函数名）。第四个参数：线程运行函数的参数。

进程同步实验报告

实验三进程的同步一、实验目的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 ，当父进程运行时创建另一个子进程。

实验3 进程同步与通信实验

exit(0);
}
}
void stop()
{
waitFlag = 0;
}
运行结果：
2.编制实现进程的管道通信的程序（选作）
源代码：
#include <unistd.h>
#include <signal.h>
#include <stdio.h>
int pid1,pid2;
main( )
{
int fd[2];
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 process 2 is sending message!\n");
源代码：
#include<stdio.h>
#include<stdlib.h>
#include<signal.h>
#include<unistd.h>
void stop();
int waitFlag;
int main()
{
int pid1, pid2;
signal(3, stop);
while((pid1 = fork()) == -1)
Child process 2 待两个子进程终止后，输出以下信息后终止。
Parent process is killed!!

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

实验三：进程同步实验一、实验任务：（1）掌握操作系统的进程同步原理；（2）熟悉linux的进程同步原语；（3）设计程序，实现经典进程同步问题。

二、实验原理：（1）P、V操作PV操作由P操作原语和V操作原语组成（原语是不可中断的过程），对信号量进行操作，具体定义如下：P（S）：①将信号量S的值减1，即S=S-1；②如果S³0，则该进程继续执行；否则该进程置为等待状态，排入等待队列。

V（S）：①将信号量S的值加1，即S=S+1；②如果S>0，则该进程继续执行；否则释放队列中第一个等待信号量的进程。

（2）信号量信号量（semaphore）的数据结构为一个值和一个指针，指针指向等待该信号量的下一个进程。

信号量的值与相应资源的使用情况有关。

当它的值大于0时，表示当前可用资源的数量；当它的值小于0时，其绝对值表示等待使用该资源的进程个数。

注意，信号量的值仅能由PV操作来改变。

一般来说，信号量S³0时，S表示可用资源的数量。

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

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

（3）linux的进程同步原语①wait()；阻塞父进程，子进程执行；②#include <sys/types.h>#include <sys/ipc.h>key_t ftok (char*pathname, char proj)；它返回与路径pathname相对应的一个键值。

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

实验共享内存与进程同步

除了链表方式，还可以使用数组，如 buffers=Data[10]; i = i mod 10;
5、编译、编辑、调试
cc –o sub1 sub1.c vi gdb
四、实验指导
主函数：main() { 创建共享内存组；
创建信号灯；信号灯赋初值；创建两个进程readbuf、writebuf; 等待两个进程运行结束；删除信号灯；删除共享内存组； } Readbuf负责读、writebuf负责写，如何定义？
int shmid,cmd; struct shmid_ds *buf; 其中，buf是用户缓冲区地址，cmd是操作命令：（1）用于查询有关共享存储区的情况。（2）用于设置或改变共享存储区的属性。（3）对共享存储区的加锁和解锁命令。（4）删除共享存储区标识符等。如shmctl(shmid,IPC_RMID,0)
实验三、共享内存与进程同步
一、实验目的
1、掌握Linux下共享内存的概念与使用方法； 2、掌握环形缓冲的结构与使用方法； 2、掌握Linux下进程同步与通信的主要机制。
二、实验内容
利用多个共享内存（有限空间）构成的环形缓冲，将源文件复制到目标文件，实现两个进程的誊抄。
三、预备知识
1、共享内存
使用共享内存是运行在同一计算机上的进程进行进程间通信的最快的方法。 shmget与shmat 系统调用：
int shmget(key_t key,int size,int shmflg) IPC_CREAT|0666 int shmat ( int shmid, char *shmaddr, int shmflg) S = (char *)shmat(shmid1,NULL,SHM_R|SHM_W)
共享存储区的控制shmctl:对其状态信息进行读取和修改。系统调用格式：int shmctl(shmid,cmd,buf);

《操作系统(A)》实验三同步机制计算机 08-1 28

班级计算机 08-1 大连交通大学姓名（28号）实验报告同组人课程名称：操作系统(A) 成绩实验名称：同步机制指导老师郭金令就绪态时，PCB中保留了断点信息，一旦进程再度占有处理器则就从断点位置继续运行；当进程处于完成状态，表示进程执行结束。

3.流程图：图4-5处理器调度程序流程图4-6 模拟处理器指令执行（1）模拟P（S （2）模拟V（S）4.打印一份源程序并附上注释、程序源码的电子版：分为四个头文件。

1、a.h头文件代码如下：#include<string.h>#include<ctype.h>#include<malloc.h> /* malloc()等*/#include<limits.h> /* INT_MAX等*/#include<stdio.h> /* EOF(=^Z或F6),NULL */#include<stdlib.h> /* atoi() */#include<io.h> /* eof() */#include<math.h> /* floor(),ceil(),abs() */#include<process.h> /* exit() */#include <iostream>using namespace std;#include <time.h>#define BUF 10 //缓存的大小#define MAX 20 //最大可以输入的字符void init(){ //初始化s1=BUF;s2=0;}}4、main头文件代码如下：#include "a.h"#include "b.h"#include "c.h"void main(){printf("*生产者消费者模拟\n");printf("—————————\n");printf("*请输入字符串:\n");scanf("%s",str); //string数组存放将要产生的字符len=strlen(str);count=len; //输入字符的个数init(); //初始化while(con_cnt<len) //消费完所有的字符为结束{system("cls"); //清屏操作printf("—————————模拟指令流程————————\n");control(); //处理器调度程序processor(); //模拟处理器指令执行print(); //输出显示各个信息}printf("\n程序结束!\n");}5.打印程序运行时的初值和运行结果，要求如下：（1）进程控制块的初始状态（2）选中运行的进程名以及选中进程运行后的各进程控制块状态。

操作系统实验报告

操作系统实验报告操作系统是计算机科学中十分重要的一门课程，本次实验是关于操作系统的，通过实验，我们可以更深入地了解操作系统的相关知识和操作。

本篇文章将着重介绍本次操作系统实验的内容和实验过程中的收获。

一、实验内容本次实验内容主要涉及操作系统的进程、线程和进程同步三部分。

具体内容包括：1. 进程的创建和管理2. 线程的创建和管理3. 进程同步的实现在实验过程中，我们将分别使用C语言和Linux操作系统实现上述功能。

二、实验过程1. 进程的创建和管理在这一部分实验中，我们要创建多个进程，实现进程的调度和管理功能。

我们采用了Linux系统下的fork()函数，用于创建子进程。

在程序运行时，首先创建一个父进程，然后使用fork()函数创建四个子进程，每个子进程都有自己的进程号(pid)，并在屏幕上输出该进程号以示区分。

为了实现进程的调度功能，我们在代码中加入了sleep()函数，用于将进程挂起一段时间，然后再轮流执行其他进程。

2. 线程的创建和管理在这一部分实验中，我们使用了C语言的POSIX线程库pthread.h，实现多线程的功能。

同样地，我们采用了Linux系统下的fork()函数来创建线程。

在代码运行时，我们创建了两个线程，并在屏幕上输出线程号(tid)以示区分。

为了实现线程的调度和管理功能，我们在代码中加入了pthread_join()函数，用于等待线程的执行完成。

3. 进程同步的实现在这一部分实验中，我们使用了Linux系统下的进程同步工具——信号量(semaphore)。

在代码中，我们使用sem_init()函数创建信号量，使用sem_wait()函数阻塞进程或线程，使用sem_post()函数释放进程或线程。

为了更好地理解信号量的工作原理，我们将代码分为生产者和消费者两部分，其中生产者用于向缓冲区添加数据，消费者则用于删除数据。

在这个过程中，我们需要使用信号量控制生产者和消费者的数量，避免出现生产过多或消费过多的情况。

整理操作系统进程同步

操作系统进程同步20 年月日A4打印/ 可编辑进程调度和进程同步实验要求实验内容：用线程模拟进程，实现进程调度和进程同步。

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

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

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

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

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

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

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

3.对于每个子线程，在其运行期间，输出其占用的时间标号（例如，第3个线程占用了第10秒的CPU时间，输出为：“Thread3：10”，格式可自行设计）。

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

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

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

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

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

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

操作系统实验报告实验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、实现一个生产者消费者问题的程序，使用信号量来实现进程之间的同步与互斥。