操作系统进程同步实验报告
操作系统实验二实验报告
操作系统实验二实验报告一、实验目的本次操作系统实验二的主要目的是深入理解和掌握进程管理的相关概念和技术，包括进程的创建、执行、同步和通信。
通过实际编程和实验操作，提高对操作系统原理的认识，培养解决实际问题的能力。
二、实验环境本次实验使用的操作系统为 Windows 10，编程环境为 Visual Studio 2019。
三、实验内容及步骤（一）进程创建实验1、首先，创建一个新的 C+＋项目。
2、在项目中，使用 Windows API 函数`CreateProcess`来创建一个新的进程。
3、为新进程指定可执行文件的路径、命令行参数、进程属性等。
4、编写代码来等待新进程的结束，并获取其退出代码。
（二）进程同步实验1、设计一个生产者消费者问题的模型。
2、使用信号量来实现生产者和消费者进程之间的同步。
3、生产者进程不断生成数据并放入共享缓冲区，当缓冲区已满时等待。
4、消费者进程从共享缓冲区中取出数据进行处理，当缓冲区为空时等待。
（三）进程通信实验1、选择使用管道来实现进程之间的通信。
2、创建一个匿名管道，父进程和子进程分别读写管道的两端。
3、父进程向管道写入数据，子进程从管道读取数据并进行处理。
四、实验结果及分析（一）进程创建实验结果成功创建了新的进程，并能够获取到其退出代码。
通过观察进程的创建和执行过程，加深了对进程概念的理解。
（二）进程同步实验结果通过使用信号量，生产者和消费者进程能够正确地进行同步，避免了缓冲区的溢出和数据的丢失。
分析结果表明，信号量机制有效地解决了进程之间的资源竞争和协调问题。
（三）进程通信实验结果通过管道实现了父进程和子进程之间的数据通信。
数据能够准确地在进程之间传递，验证了管道通信的有效性。
五、遇到的问题及解决方法（一）在进程创建实验中，遇到了参数设置不正确导致进程创建失败的问题。
通过仔细查阅文档和调试，最终正确设置了参数，成功创建了进程。
（二）在进程同步实验中，出现了信号量使用不当导致死锁的情况。
操作系统 实验三 进程同步
集美大学计算机工程学院实验报告课程名称：操作系统指导教师：王丰实验成绩：实验编号：实验三实验名称：进程同步班级：计算12姓名：学号：上机实践日期：2015.5上机实践时间：2学时一、实验目的1、掌握用Linux信号灯集机制实现两个进程间的同步问题。
2、共享函数库的创建二、实验环境Ubuntu-VMware、Linux三、实验内容⏹需要的信号灯: System V信号灯实现☐用于控制司机是否可以启动车辆的的信号灯 S1=0☐用于控制售票员是否可以开门的信号灯 S2=0System V信号灯实现说明□ System V的信号灯机制属于信号灯集的形式, 一次可以申请多个信号灯.□同样利用ftok()生成一个key： semkey=ftok(path,45);□利用key申请一个包含有两个信号灯的信号灯集, 获得该集的idsemid=semget(semkey,2,IPC_CREAT | 0666);□定义一个联合的数据类型union semun{int val;struct semid_ds *buf;ushort *array;};□利用semctl()函数对信号灯初始化,参数有:信号灯集的id: semid要初始化的信号灯的编号:sn要设定的初始值:valvoid seminit(int semid, int val,int sn){union semun arg;arg.val=val;semctl(semid,sn,SETVAL,arg);}利用初始化函数,初始化信号灯:seminit(semid,0,0);//用来司机启动汽车的同步seminit(semid,0,1);//用来售票员开门的同步控制□利用semop()函数, 对信号灯实现V操作:sembuf是一个在头部文件中的预定义结构、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);}2、Linux的静态和共享函数库·Linux生成目标代码： gcc -c 源程序文件名（将生成一个与源程序同名的.o目标代码文件。
进程的同步与互斥实验报告
进程的同步与互斥实验报告1.实验目的进程（线程）的同步与互斥是操作系统中非常重要的概念，本实验旨在通过实际操作，加深对这些概念的理解和掌握。
通过编写多个进程（线程），并在其间进行同步与互斥操作，验证同步与互斥的实际效果。
2.实验环境本实验在Linux系统下进行，使用C/C++语言编程。
3.实验内容3.1同步在实验中，我们编写了两个进程A和B，这两个进程需要按照特定的顺序执行。
为了实现同步，我们使用信号量机制来确保进程A和B按照正确的顺序执行。
3.2互斥在实验中，我们编写了多个进程C和D，这些进程需要同时对一个共享资源进行访问。
为了实现互斥，我们使用互斥锁机制来确保同一时刻只有一个进程访问共享资源。
4.实验过程4.1同步实验编写进程A和进程B的代码，使用信号量机制实现同步。
进程A先运行，然后通过信号量唤醒进程B，进程B再开始执行。
通过观察进程的运行顺序，验证同步机制是否起作用。
4.2互斥实验编写进程C和进程D的代码，使用互斥锁机制实现互斥。
进程C和进程D同时对一个共享资源进行访问，通过互斥锁来确保同一时刻只有一个进程访问共享资源。
观察进程的输出结果，验证互斥机制是否起作用。
5.实验结果5.1同步实验结果进程A开始执行进程A执行完毕进程B开始执行进程B执行完毕5.2互斥实验结果进程C开始执行进程C访问共享资源进程C执行完毕进程D开始执行进程D访问共享资源进程D执行完毕6.实验分析通过上述结果可以看出，同步实验中进程A和进程B按照正确的顺序执行，证明了同步机制的有效性。
互斥实验中进程C和进程D能够正确地交替访问共享资源，证明了互斥机制的有效性。
7.实验总结通过本次实验，我深刻理解了进程（线程）的同步与互斥，并通过实际操作加深了对这些概念的理解。
同步和互斥是操作系统中非常重要的概念，对于应对资源竞争和提高程序性能具有重要意义。
在实际开发中，我们应该合理使用同步和互斥机制，以确保程序的正确性和并发执行的效率。
进程同步实验报告
一、实验目的1. 理解进程同步的概念和原理；2. 掌握进程同步的基本方法和机制；3. 学会使用信号量实现进程同步；4. 通过实验验证进程同步机制的有效性。
二、实验原理1. 进程同步：在多道程序设计中，进程的执行是并发的，但某些情况下需要保证多个进程按照一定的顺序执行，以避免出现数据不一致、死锁等问题。
进程同步是指通过某种机制，协调多个进程的执行顺序，保证它们能够正确、有效地共享资源。
2. 信号量：信号量是一种特殊的变量，用于实现进程同步。
信号量具有两个原子操作：P操作（wait）和V操作（signal）。
P操作用于申请资源，V操作用于释放资源。
3. 互斥锁：互斥锁是一种常见的进程同步机制，用于保证临界资源的互斥访问。
当一个进程进入临界区时，它会尝试获取互斥锁，如果锁已被其他进程获取，则该进程进入等待状态；当进程退出临界区时，它会释放互斥锁。
三、实验内容1. 实验环境：Linux操作系统，C语言编程环境。
2. 实验工具：gcc编译器、gdb调试器。
3. 实验步骤：（1）创建一个互斥锁，用于保护临界资源。
（2）编写两个进程，分别模拟对临界资源的访问。
（3）在进程访问临界资源前，使用P操作尝试获取互斥锁。
（4）在进程访问临界资源后，使用V操作释放互斥锁。
（5）编译并运行程序，观察进程执行情况。
四、实验结果与分析1. 实验结果：（1）在互斥锁的保护下，两个进程能够按照预期顺序访问临界资源。
（2）当其中一个进程正在访问临界资源时，另一个进程会进入等待状态。
（3）当进程访问临界资源完成后，它会释放互斥锁，允许其他进程访问。
2. 实验分析：（1）互斥锁能够有效地保护临界资源，避免数据不一致问题。
（2）信号量P操作和V操作保证了进程的同步，避免了死锁现象。
（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.生产者线程：生产者线程交替执行如下两个阶段：睡眠一段随机事件，向缓冲中插入一个随机数。
进程管理实验报告分析(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. 实验四：分析利用软中断通信实现进程同步的机理在实验四中，我们分析了利用软中断通信实现进程同步的机理。
进程同步实验报告
中北大学软件学院实验报告专 业： 软件工程方 向： 软件开发与测试课程名称： 操作系统班 级：学 号：姓 名：辅导教师：2017年9月制成绩：实验时间2017年11月5日8时至10时学时数22学时1.实验名称进程同步2.实验内容编程实现生产者-消费者问题的模拟。
3.基本要求1.生产者消费者对缓冲区进行互斥操作。
2. 缓冲区大小为10，缓冲区满则不允许生产者生产数据，缓冲区空则不允许消费者消费数据。
3. 生产者消费者各循环操作10次。
4. 实验原理或流程图生产者-消费者问题是一个经典的进程同步问题，该问题最早由Dijkstra提出，用以演示他提出的信号量机制。
在同一个进程地址空间内执行的两个线程。
生产者线程生产物品，然后将物品放置在一个空缓冲区中供消费者线程消费。
消费者线程从缓冲区中获得物品，然后释放缓冲区。
当生产者线程生产物品时，如果没有空缓冲区可用，那么生产者线程必须等待消费者线程释放出一个空缓冲区。
当消费者线程消费物品时，如果没有满的缓冲区，那么消费者线程将被阻塞，直到新的物品被生产出来。
5.源程序#i n c l u d e<s t d i o.h>#i n c l u d e<p t h r e a d.h>#i n c l u d e<s e m a p h o r e.h>#i n c l u d e<u n i s t d.h>v o i d*p r o d u c t e r_f(v o i d*a r g);v o i d*c o n s u m e r_f(v o i d*a r g);s e m_t e m p t y;//信号量e m p t ys e m_t f u l l;//信号量f u l li n t r u n n i n g=1;i n t a p p l e_n u m=0;i n t m a i n(v o i d){p t h r e a d_t c o n s u m e r_t;//消费者p t h r e a d_t p r o d u c t e r_t;//生产者//p s h a r e d表示信号量共享类型， 为0时，表示只能在当前进程的//多个线程之间共享，不为0时，是可以和其他进程间共享该信号量//使用信号量，用来协作生产者和消费者的顺序，即实现同步效果s e m_i n i t(&e m p t y,0,1);//初始化e m p t y信号量s e m_i n i t(&f u l l,0,0);//初始化f u l l信号量p t h r e a d_c r e a t e(&c o n s u m e r_t,N U L L,c o n s u m e r_f,(v o i d*)&r u n n i n g); //创建消费者线程p t h r e a d_c r e a t e(&p r o d u c t e r_t,N U L L,p r o d u c t e r_f,(v o i d*)&r u n n i n g);//创建生产者线程//s l e e p(1);//睡眠3秒u s l e e p(1000);//睡眠10微秒r u n n i n g=0;p t h r e a d_j o i n(c o n s u m e r_t,N U L L);p t h r e a d_j o i n(p r o d u c t e r_t,N U L L);s e m_d e s t r o y(&e m p t y);s e m_d e s t r o y(&f u l l);r e t u r n0;}v o i d*p r o d u c t e r_f(v o i d*a r g){w h i l e(*(i n t*)a r g){s e m_w a i t(&e m p t y);a p p l e_n u m++;p r i n t f("p r o d u c t e r生产第%d个香蕉\n",a p p l e_n u m);s e m_p o s t(&f u l l);u s l e e p(1);}}v o i d*c o n s u m e r_f(v o i d*a r g){w h i l e(*(i n t*)a r g){s e m_w a i t(&f u l l);p r i n t f("c o n s u m e r消费第%d个香蕉\n",a p p l e_n u m);s e m_p o s t(&e m p t y);u s l e e p(1);}}6.运行截图7.实验心得本次实验学习了进程的同步问题，进程是计算机操作系统重要的一个功能，学好进程才能学好其他。
操作系统实验三实验报告
（一）进程创建
编写程序实现创建多个进程，并观察进程的执行情况。通过调用Windows API函数｀CreateProcess`来创建新的进程。在创建进程时，设置不同的参数，如进程的优先级、命令行参数等，观察这些参数对进程执行的影响。
（二）进程控制
实现对进程的暂停、恢复和终止操作。使用｀SuspendThread`和｀ResumeThread`函数来暂停和恢复进程中的线程，使用｀TerminateProcess`函数来终止进程。通过控制进程的执行状态，观察系统的资源使用情况和进程的响应。
（一）进程创建实验结果与分析
创建多个进程后，通过任务管理器观察到新创建的进程在系统中运行。不同的进程优先级设置对进程的CPU占用和响应时间产生了明显的影响。高优先级的进程能够更快地获得CPU资源，执行速度相对较快；而低优先级的进程则在CPU资源竞争中处于劣势，可能会出现短暂的卡顿或计一个多进程同步的程序，使用信号量、互斥量等同步机制来协调多个进程的执行。例如，实现一个生产者消费者问题，多个生产者进程和消费者进程通过共享缓冲区进行数据交换，使用同步机制来保证数据的一致性和正确性。
四、实验步骤
（一）进程创建实验步骤
1、打开Visual Studio 2019，创建一个新的C+＋控制台应用程序项目。
六、实验中遇到的问题及解决方法
（一）进程创建失败
在创建进程时，可能会由于参数设置不正确或系统资源不足等原因导致创建失败。通过仔细检查参数的设置，确保命令行参数、环境变量等的正确性，并释放不必要的系统资源，解决了创建失败的问题。
（二）线程控制异常
在暂停和恢复线程时，可能会出现线程状态不一致或死锁等异常情况。通过合理的线程同步和错误处理机制，避免了这些异常的发生。在代码中添加了对线程状态的判断和异常处理的代码，保证了线程控制的稳定性和可靠性。
进程的同步实验报告
操作系统实验报告哈尔滨工程大学计算机科学与技术学院进程的同步一．实验概述1.实验名称：进程的同步2.实验目的：1）使用EOS 的信号量，编程解决生产者—消费者问题，理解进程同步的意义；2）调试跟踪EOS 信号量的工作过程，理解进程同步的原理；3）修改EOS 的信号量算法，使之支持等待超时唤醒功能（有限等待），加深理解进程同步的原理。
3.实验类型：验证+设计4.实验内容：1）准备实验2）使用EOS 的信号量解决生产者－消费者问题3）调试EOS 信号量的工作过程4）修改EOS 的信号量算法二．实验环境操作系统：windows XP编译器：Tevalaton OS Lab语言：C三．实验过程1.设计思路和流程图2.实验过程1）准备实验，启动OS Lab，新建一个EOS Kernel项目和EOS应用程序，将EOS Kernel 项目中生成的SDK文件覆盖到ROS应用程序项目文件夹中的SDK文件夹；2）使用pc.c文件中的源代码，替换之前创建的EOS应用程序项目中EOSApp.c文件中的代码，并生成项目，启动调试，忽略调试的异常，立即激活虚拟机窗口中查看生产者－消费者同步执行的过程，结束此次调试；3）信号量结构体（SEMAPHORE）中的各个成员变量是由API 函数CreateSemaphore 的对应参数初始化的。
创建信号量，启动调试EOS应用程序，在OS Lab弹出的调试异常对话框中选择“是”，进入异常调试，在main函数中创建Empty信号量的代码行添加断点；EmptySemaphoreHandle = CreateSemaphore(BUFFER_SIZE, BUFFER_SIZE, NULL);4）启动调试，逐语句调试进入CreateSemaphore 函数。
可以看到此API 函数只是调用了EOS内核中的PsCreateSemaphoreObject 函数来创建信号量对象，继续逐语句调试试进入semaphore.c 文件中的PsCreateSemaphoreObject 函数。
操作系统实验报告——进程同步与互斥
操作系统实验报告——进程同步与互斥一、实验内容本实验主要内容是通过编写程序来实现进程的同步与互斥。
具体来说，是通过使用信号量来实现不同进程之间的同步和互斥。
我们将编写两个进程，一个进程负责打印奇数，另一个进程负责打印偶数，两个进程交替打印，要求打印的数字从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. 创建进程：能够创建新的进程，并为其分配资源。
2. 进程调度：能够根据进程的优先级和调度算法，合理地调度进程的执行顺序。
3. 进程同步：能够实现进程间的同步与互斥，避免资源竞争和死锁问题。
二、实验环境和工具本实验使用的实验环境和工具如下：1. 操作系统：Windows 102. 编程语言：C++3. 开发工具：Visual Studio 2019三、实验过程和结果1. 进程创建在实验中，我们首先实现了进程的创建功能。
通过调用操作系统提供的系统调用接口，我们能够创建新的进程，并为其分配资源。
具体的实现过程涉及到进程控制块（PCB）的创建和初始化，以及资源的分配和管理。
通过编写测试程序，我们成功创建了多个进程，并验证了进程创建功能的正确性。
2. 进程调度进程调度是操作系统中非常重要的功能之一，它决定了进程的执行顺序和时间片的分配。
在实验中，我们实现了简单的进程调度算法，采用了轮转调度算法。
通过设计合适的数据结构和算法，我们能够按照一定的优先级和时间片大小，合理地安排进程的执行顺序。
通过编写测试程序，我们验证了进程调度功能的正确性。
3. 进程同步在多进程环境下，进程间的同步与互斥是非常重要的问题。
在实验中，我们实现了进程同步功能，通过使用信号量和互斥锁，实现了进程间的同步与互斥。
通过编写测试程序，我们验证了进程同步功能的正确性，并且能够避免资源竞争和死锁问题。
操作系统实验之进程管理实验报告
操作系统实验之进程管理实验报告一、实验目的本次操作系统实验的主要目的是深入理解进程管理的概念和原理，通过实际操作和观察，掌握进程的创建、调度、同步与互斥等关键机制。
二、实验环境本次实验使用的操作系统为 Windows 10，开发工具为 Visual Studio 2019，编程语言为 C+＋。
三、实验内容1、进程创建使用系统提供的 API 函数创建新的进程。
观察新进程的资源使用情况和运行状态。
2、进程调度编写程序模拟不同的进程调度算法，如先来先服务（FCFS）、短作业优先（SJF）和时间片轮转（RR）。
比较不同调度算法下的平均周转时间、平均等待时间等性能指标。
3、进程同步与互斥利用信号量、互斥锁等机制实现进程之间的同步与互斥。
设计并发程序，解决生产者消费者问题、读写者问题等经典同步问题。
四、实验步骤1、进程创建实验首先，包含所需的头文件，如｀＜windowsh>｀。
然后，定义创建进程的函数，使用｀CreateProcess` 函数创建新进程，并获取进程的相关信息，如进程标识符、线程标识符等。
最后，通过查看任务管理器或其他系统工具，观察新创建进程的资源占用情况。
2、进程调度实验设计不同的调度算法函数，如｀FCFSSchedule`、｀SJFSchedule` 和｀RRSchedule`。
在每个调度算法函数中，模拟进程的到达时间、服务时间等参数，并按照相应的算法进行进程调度。
计算每个进程的周转时间和等待时间，并求出平均周转时间和平均等待时间。
3、进程同步与互斥实验定义信号量或互斥锁变量。
在生产者消费者问题中，生产者在生产产品时获取互斥锁，生产完成后释放互斥锁并通知消费者；消费者在消费产品时获取互斥锁，消费完成后释放互斥锁。
在读写者问题中，读者在读取数据时获取共享锁，读完后释放共享锁；写者在写入数据时获取独占锁，写入完成后释放独占锁。
五、实验结果与分析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 银行家算法之例所用数据《计算机操作系统》（第三版）西安电子科技大学出版社银行家算法原理说明：银行家算法是一种最有代表性的避免死锁的算法。
操作系统实验4-4实验报告
操作系统实验4-4实验报告一、实验目的本次操作系统实验 4-4 的目的是深入了解和掌握操作系统中进程管理的相关知识和技术，通过实际操作和观察，加深对进程调度算法、进程同步与互斥等概念的理解，并提高解决实际问题的能力。
二、实验环境本次实验使用的操作系统为 Windows 10，编程环境为 Visual Studio 2019。
三、实验内容1、进程调度算法的实现先来先服务（FCFS）算法短作业优先（SJF）算法时间片轮转（RR）算法优先级调度算法2、进程同步与互斥的实现使用信号量实现生产者消费者问题使用互斥锁实现哲学家进餐问题四、实验步骤1、进程调度算法的实现先来先服务（FCFS）算法设计数据结构来表示进程，包括进程ID、到达时间、服务时间等。
按照进程到达的先后顺序将它们放入就绪队列。
从就绪队列中选择第一个进程进行处理，计算其完成时间、周转时间和带权周转时间。
短作业优先（SJF）算法在设计的数据结构中增加作业长度的字段。
每次从就绪队列中选择服务时间最短的进程进行处理。
计算相关的时间指标。
时间片轮转（RR）算法设定时间片的大小。
将就绪进程按照到达时间的先后顺序放入队列。
每个进程每次获得一个时间片的执行时间，若未完成则重新放入队列末尾。
优先级调度算法为每个进程设置优先级。
按照优先级的高低从就绪队列中选择进程执行。
2、进程同步与互斥的实现生产者消费者问题创建一个共享缓冲区。
生产者进程负责向缓冲区中生产数据，消费者进程从缓冲区中消费数据。
使用信号量来控制缓冲区的满和空状态，实现进程的同步。
哲学家进餐问题模拟多个哲学家围绕一张圆桌进餐的场景。
每个哲学家需要同时获取左右两边的筷子才能进餐。
使用互斥锁来保证筷子的互斥访问，避免死锁的发生。
五、实验结果与分析1、进程调度算法的结果与分析先来先服务（FCFS）算法优点：实现简单，公平对待每个进程。
缺点：对短作业不利，平均周转时间可能较长。
短作业优先（SJF）算法优点：能有效降低平均周转时间，提高系统的吞吐量。
操作系统实验报告
操作系统实验报告操作系统是计算机科学中十分重要的一门课程，本次实验是关于操作系统的，通过实验，我们可以更深入地了解操作系统的相关知识和操作。
本篇文章将着重介绍本次操作系统实验的内容和实验过程中的收获。
一、实验内容本次实验内容主要涉及操作系统的进程、线程和进程同步三部分。
具体内容包括：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()函数释放进程或线程。
为了更好地理解信号量的工作原理，我们将代码分为生产者和消费者两部分，其中生产者用于向缓冲区添加数据，消费者则用于删除数据。
在这个过程中，我们需要使用信号量控制生产者和消费者的数量，避免出现生产过多或消费过多的情况。
北邮大三上-操作系统-进程同步实验报告
操作系统实验二进程同步实验班级：2009211311 学号：姓名：schnee目录1. 实验目的 (2)2. 实验要求 (2)3. 环境说明 (2)4. 实验前期思考 (2)5. 实验知识点储备 (3)5.1.进程 (3)5.2.线程 (3)5.3.同步和互斥 (3)5.4.库函数和类型储备 (4)6. 编程实现： (6)6.1. 调整和框架 (6)6.2. 源程序实现（详细框架见注释） (6)6.3. 实现中遇到过的困难和解决方法 (9)6.4. 运行示例及结果截图 (10)7. 心得和优化 (11)1.实验目的1）理解进程/线程同步的方法，学会运用进程/线程同步的方法解决实际问题；2）了解windows系统或unix/linux系统下中信号量的使用方法。
2.实验要求编写一个有关生产者和消费者的程序：每个生产者每次生产一个产品存入仓库，每个消费者每次从仓库中取出一个产品进行消费，仓库大小有限，每次只能有一个生产者或消费者访问仓库。
要求:采用信号量机制。
3.环境说明此实验采用的是Win7下Code::blocks 10.05编译器，采用Win API的信号量机制编程。
此word实验文档中采用notepad++的语法高亮。
4.实验前期思考可能有多个生产者和消费者。
可以假设输入P表示创建一个生产者线程，输入C表示创建一个消费者线程。
生产者线程等待仓库有空位并且占据此空位，，然后等待仓库的操作权，执行操作，最后释放仓库操作权。
一开始以为是占位的操作在获得操作权后，疑惑：若是等待空位后在等待获得操作权时又没有空位了，岂不是又不能放入了？若是先获得操作权再等空位，则在无空位时会进入无穷等待状态，因为没有人来改变空位个数。
这两个问题如何克服呢？其实第一个疑问是因为我对wait函数的具体操作还有点模糊，实际上wait操作便是一等到空位就顺便占了，而不是我想的等位和占位分离。
而第二个问题自然是不行的，这种操作顺序应该抛弃。
操作系统进程同步与互斥实验报告0204192337
学生实验报告姓名：年级专业班级学号成绩#define N 1 //N定义为临界资源!printf("请输入三个进程:\n"); //初始状态为：临界资源处于空闲状态!loop:scanf("%d %d %d",&a,&b,&c); //输入的进程名为:a,b,c!进程名输入的先后代表进程的访问顺序！if(a==N) //判断进程a是否占据临界资源!若a==N,表明a访问临界资源！{printf("a=%d\n",a); //a正在访问临界资源！printf("b=0,c=0\n"); //b,c不能进入自己的临界区，需等待a释放临界资源!printf(“临界资源正在被进程a访问,进程b,c必须等待.\n”);}else if(b==N){printf("b=%d\n",b); //b正在访问临界资源!printf("a=0,c=0\n"); //a,c不能进入自己的临界区，需等待b释放临界资源！printf(“临界资源正在被进程b访问,进程a,c必须等待.\n”);}5.编译链接所编写的程序,在编译正确的情况下执行程序.6.记录程序执行的结果(如下图所示).注意:初始状态为:临界资源处于空闲状20 10年12 月16 日【实验结果或总结】（对实验结果进行相应分析，或总结实验的心得体会，并提出实验的改进意见）1.进程a,b,c分别访问临界资源时程序执行的结果如下.(a) (b) (c)2.该程序初始化N为临界资源，根据输入a,b,c,的值是否等于N来判断进程分别是否进入自己的临界区。
当a=N 表明进程a正在访问临界资源。
此时程序执行的输出为：a=1,b=c=0表示进程b,c不能进入自己的临界区。
3.该程序能较好地体现程序并发执行时的一种制约关系-互斥，但不能较好的反映进程的同步关系，所以该算法有待改进，用以同时实现进程的同步和互斥。
操作系统进程同步实验报告
操作系统进程同步实验报告本实验旨在通过模拟操作系统中进程的同步问题，加深学生对操作系统中进程同步机制的了解和实践能力。
本次实验分为两个部分，第一个部分是使用信号量实现进程同步，第二个部分是使用管程实现进程同步。
第一部分实验：使用信号量实现进程同步本部分实验的目标是使用信号量来实现进程同步，确保资源的互斥访问。
在Linux系统中，信号量是一种用来控制进程同步的机制，可以用于保证共享资源的互斥访问、避免死锁等问题。
具体实验流程如下：1. 定义一个信号量，用于互斥访问共享资源在Linux系统中，使用semget函数可以创建一个信号量集，使用semctl函数可以对信号量进行控制。
```#include <sys/types.h>#include <sys/ipc.h>#include <sys/sem.h>#define KEY 1234 // 定义信号量的键值int semid; // 定义信号量标识符union semun{int val; // 信号量的初始值struct semid_ds *buf; // IPC_STAT, IPC_SET操作时用ushort *array; // GETALL, SETALL操作时用};void init_sem(){int ret;union semun semunion;// 创建信号量semid = semget(KEY, 1, IPC_CREAT | 0666);if(semid == -1){perror("semget error");exit(1);}2. 定义生产者和消费者进程，并使用信号量来实现同步在生产者和消费者进程中，需要先对信号量进行P操作，即申请资源，然后进行对共享资源的操作，最后再对信号量进行V操作，即释放资源。
本实验中，共享资源是一个循环缓冲区，生产者进程向其中写入数据，消费者进程从中读取数据。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验三：进程同步实验一、实验任务：（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参数是一些标志位。
参数key和semflg的取值，以及何时打开已有信号灯集或者创建一个新的信号灯集与msgget()中的对应部分相同。
该调用返回与健值key相对应的信号灯集描述字。
调用返回：成功返回信号灯集描述字，否则返回-1。
④int semop(int semid, struct sembuf *sops, unsigned nsops);semid是信号灯集ID，sops指向数组的每一个sembuf结构都刻画一个在特定信号灯上的操作。
nsops为sops指向数组的大小。
⑤int semctl(int semid，int semnum，int cmd，union semun arg)该系统调用实现对信号灯的各种控制操作，参数semid指定信号灯集，参数cmd指定具体的操作类型；参数semnum指定对哪个信号灯操作，只对几个特殊的cmd操作有意义；arg用于设置或返回信号灯信息。
三、实验源程序：#include<sys/types.h>#include<sys/ipc.h>#include<sys/sem.h>#include<errno.h>#include<stdlib.h>#include<stdio.h>#include<fcntl.h>#include<unistd.h>#include <string.h>#include <sys/stat.h>#include <sys/types.h>#include <sys/ipc.h>#include <sys/shm.h>#define PERM S_IRUSR|S_IWUSR#define SEMKEY (key_t)0x200typedef union _senum{int val;struct semid_ds *buf;ushort *array;}semun;int semid;static int count=0;FILE *fp,*fp1,*fp2;struct sembuf prmutex={0,-1,0},pwmutex={1,-1,0},ps={2,-1,0}; struct sembuf vrmutex={0,1,0},vwmutex={1,1,0},vs={2,1,0}; int initsem(){semun x;x.val=1;if((semid=semget(SEMKEY,3,0600|IPC_CREAT|IPC_EXCL))==-1) {if(errno==EEXIST)semid=semget(SEMKEY,3,0);}if(semctl(semid,0,SETV AL,x)==-1){perror("semctl failed\n");return(-1);}if(semctl(semid,1,SETV AL,x)==-1){perror("semctl failed\n");return(-1);}if(semctl(semid,2,SETV AL,x)==-1){perror("semctl failed\n");return(-1);}return(semid);}main(){int i,j,k;static int a[30];int shmid;int *pint,*pint2,addr,addr2;for(i=0;i<30;i++){a[i]=i;}if((shmid=shmget(IPC_PRIV ATE,4,PERM))==-1) {fprintf(stderr,"Create Share Memory Error:%s\n\a",strerror(errno)); exit(1);}addr=shmat(shmid,0,0) ;pint=(int*)addr;*pint=0;semid=initsem();if(fork()==0){ //writersemop(semid,&pwmutex,1);printf("call writer\n");fp1=fopen("a.txt","w");for(k=0;k<20;k++){fprintf(fp1,"%d\n ",5*k);printf("write %d\n ",5*k);}fclose(fp1);printf("write finish\n");semop(semid,&vwmutex,1);exit(0);}else{if(fork()==0){//reader 1semop(semid,&prmutex,1);addr2=shmat(shmid,0,0);pint2=(int*)addr2;if(*pint2==0) semop(semid,&pwmutex,1);*pint2=*pint2+1;printf("reader 1 enter---- count=%d\n",*pint2);semop(semid,&vrmutex,1);fp=fopen("a.txt","r");while(!feof(fp)){fscanf(fp,"%d ",&i);printf("reader 1 %d\n ",i);}semop(semid,&prmutex,1);*pint2=*pint2-1;printf("reader 1 exit---- count=%d\n",*pint2);//count=count-1;//printf("count=%d\n",count);if(*pint2==0) semop(semid,&vwmutex,1); semop(semid,&vrmutex,1);exit(0);}else{ if(fork()==0) //reader{semop(semid,&prmutex,1);addr2=shmat(shmid,0,0);pint2=(int*)addr2;if(*pint2==0) semop(semid,&pwmutex,1);*pint2=*pint2+1;printf("Read 2 enter+++++ count=%d\n",*pint2);// printf("Read 2 count=%d\n",count);//count=2;//printf("count=%d\n",count);semop(semid,&vrmutex,1);fp=fopen("a.txt","r");while(!feof(fp)){ fscanf(fp,"%d ",&i);printf("reader 2 %d\n ",i);}semop(semid,&prmutex,1);//count=count-1;*pint2=*pint2-1;printf("Read 2 exit+++++ count=%d\n",*pint2);//printf("Read 2 count=%d\n",count);if(*pint2==0) semop(semid,&vwmutex,1);semop(semid,&vrmutex,1);exit(0);}}}}四、实验结果：。