进程的同步实验报告
进程(线程)同步和互斥实验报告
进程(线程)同步和互斥实验报告操作系统实验报告课程名称操作系统实验名称进程(线程)的同步与互斥成绩学生姓名作业君专业软件工程班级、学号同组者姓名无实验日期2021一、实验题目: : 进程(线程)的同步与互斥二、实验目的:自行编制模拟程序,通过形象化的状态显示,加深理解进程的概念、进程之间的状态转换及其所带来的 PCB 内容、组织的变化,理解进程与其 PCB 间的一一对应关系。
1.掌握基本的同步与互斥算法,理解生产者消费者模型。
2.学习使用 Windows 中基本的同步对象,掌握相关 API 的使用方法。
3.了解 Windows 中多线程的并发执行机制,实现进程的同步与互斥三、实验内容与要求:1.实验内容以生产者/消费者模型为依据,在 Windows 环境下创建一个控制台进程,在该进程中创建 n 个线程模拟生产者和消费者,实现进程(线程)的同步与互斥。
2.实验要求学习并理解生产者/消费者模型及其同步/互斥规则;学习了解 Windows 同步对象及其特性;熟悉实验环境,掌握相关 API 的使用方法;设计程序,实现生产者/消费者进程(线程)的同步与互斥;四、算法描述(含数据结构定义)或流程图#include <Windows.h> #include <iostream> #include<stdio.h> #include <math.h> #include <stdlib.h> #include <time.h> using namespace std;#define MA__THREAD_NUM 64//最大线程数 #define INTE_PER_SEC 1000//延迟时间的毫秒值 const int SIZE_OF_BUFFER = 10;//缓冲区长度 int ProductID = 0;//产品号 int ConsumeID = 0;//将被消耗的产品号 int in = 0;//产品进缓冲区时的缓冲区下标 int out = 0;//产品出缓冲区时的缓冲区下标 bool running = true;//判断程序能否继续执行的逻辑值 intg_buffer[SIZE_OF_BUFFER];//缓冲区是个循环队列 HANDLE g_hMute_;//公有信号量,用于线程间的互斥 HANDLEg_hFullSemaphore;//生产者的私有信号量,当缓冲区满时迫使生产者等待HANDLE g_hEmptySemaphore;//消费者的私有信号量,当缓冲区空时迫使消费者等待//定义一个结构体用于存储线程的信息 struct ThreadInfo {int serial;//线程号char entity;//线程类别(生产者或消费者)double delay;//等待时间double persist; //操作时间 };//生产者 void Producer(void_p) {//定义变量用于存储当前线程的信息DWORD m_delay;DWORD m_persist;int m_serial;//从参数中获得信息m_serial = ((ThreadInfo_)(p))->serial;m_delay = (DWORD)(((ThreadInfo_)(p))->delay _INTE_PER_SEC);m_persist = (DWORD)(((ThreadInfo_)(p))->persist _INTE_PER_SEC);while (running){//P 操作cout << “生产者线程” << m_serial << “ 请求生产.” << endl;WaitForSingleObject(g_hEmptySemaphore, INFINITE);cout << “生产者线程” << m_serial << “ 请求独占缓冲区.” << endl;WaitForSingleObject(g_hMute_, INFINITE);Sleep(m_delay);//延迟等待//生产一个产品cout << “生产者线程”<< m_serial << “ 生产” << ++ProductID << “ 号产品成功.” << endl;cout << “生产者线程” << m_serial << “ 请求将产品” << ProductID << “ 投入缓冲区.” << endl;//把新生产的产品放入缓冲区g_buffer[in] = ProductID;in = (in +1)%SIZE_OF_BUFFER;Sleep(m_persist);//操作等待cout << “生产者线程” << m_serial << “ 将产品” << ProductID << “ 投入缓冲区中成功.” << endl;//输出缓冲区当前的状态cout << “____________________________” << endl<< “\n 当前缓冲区情况如图(■代表已有产品,□代表没有产品):” << endl;for (int i = 0;i < SIZE_OF_BUFFER;++i){if (g_buffer[i] != 0)cout << “■”;elsecout << “□”;}cout << “\n\n____________________________\n” << endl;//V 操作ReleaseMute_(g_hMute_);ReleaseSemaphore(g_hFullSemaphore, 1, NULL);} }//消费者 void Consumer(void_p) {DWORD m_delay;DWORD m_persist;int m_serial;//从参数中获得信息m_serial = ((ThreadInfo_)(p))->serial;m_delay = (DWORD)(((ThreadInfo_)(p))->delay _INTE_PER_SEC);m_persist = (DWORD)(((ThreadInfo_)(p))->persist _INTE_PER_SEC);while (running){//P 操作cout << “消费者线程” << m_serial << “ 请求消费.” << endl;WaitForSingleObject(g_hFullSemaphore, INFINITE);cout << “消费者线程” << m_serial << “ 请求独占缓冲区.” << endl;WaitForSingleObject(g_hMute_,INFINITE);Sleep(m_delay); //延迟等待//从缓冲区中取出一个产品cout << “消费者线程” << m_serial << “ 请求取出一个产品.” << endl;ConsumeID = g_buffer[out];g_buffer[out] = 0;out = (out + 1) % SIZE_OF_BUFFER;cout << “消费者线程” << m_serial << “ 取出产品” << ConsumeID << “ 成功.” << endl;//消耗一个产品cout << “消费者线程” << m_serial << “ 开始消费消费产品” << ConsumeID << “.” << endl;Sleep(m_persist);cout << “消费者线程” << m_serial << “ 消费产品” << ConsumeID << “ 成功.” << endl;//输出缓冲区当前的状态cout << “____________________________” << endl<< “\n 当前缓冲区情况如图:” << endl;for (int i = 0;i < SIZE_OF_BUFFER;++i){if (g_buffer[i] != 0)cout << “■”;elsecout << “□”;}cout << “\n\n____________________________\n” << endl;//V 操作ReleaseMute_(g_hMute_);ReleaseSemaphore(g_hEmptySemaphore, 1, NULL);} }void prod_cons {//创建互斥信号量g_hMute_ = CreateMute_(NULL, FALSE, NULL);//创建同步信号量g_hEmptySemaphore = CreateSemaphore(NULL,SIZE_OF_BUFFER, SIZE_OF_BUFFER, NULL);g_hFullSemaphore = CreateSemaphore(NULL, 0,SIZE_OF_BUFFER, NULL);srand((unsigned)time(NULL));//以时间函数为种子const unsigned short THREADS_COUNT = rand % 5 + 5; //总的线程数(随机生成)//线程对象的数组HANDLE hThreads[MA__THREAD_NUM];ThreadInfo thread_info[MA__THREAD_NUM];DWORD thread_ID; //线程 IDint num = 0;//临时变量,用于循环语句cout << “系统开始模拟,并自动生成模拟数据...” << endl;system(“pause”); //暂停确认开始执行cout << “线程总数:” << THREADS_COUNT << endl;//循环随机生成各个线程的信息while (num != THREADS_COUNT){thread_info[num].serial = num + 1;if (rand % 2 == 1)thread_info[num].entity = "P";elsethread_info[num].entity = "C";thread_info[num].delay = rand % 5 + 1;thread_info[num].persist = rand % 6 + 2;num++;}cout << “\n 系统生成数据结束,模拟数据如下:” << endl<< “线程号线程类别延迟时间操作时间” << endl;for (int _ = 0;_ < THREADS_COUNT;_++)cout << “” << thread_info[_].serial << “\t”<< “” << thread_info[_].entity << “\t”<< “” << thread_info[_].delay << “\t\t”<< “” << thread_info[_].persist << endl;cout << “\n\n==================生产者-消费者开始==================\n” << endl;//创建线程for (int i = 0;i < THREADS_COUNT;i++){//创建生产者线程if (thread_info[i].entity == "P")hThreads[i] = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)(Producer), ;thread_info[i], 0, ;thread_ID);//创建消费者线程elsehThreads[i] = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)(Consumer), ;thread_info[i], 0, ;thread_ID);}while (running){if (getchar){//按回车后终止程序运行running = false;}}cout << “系统模拟结束...” << endl; } int main {cout << “\n==================生产者-消费者模拟==================\n” << endl;prod_cons; }五、实验过程1、记录生产者和消费者的同步执行过程。
进程的同步与互斥实验报告
进程的同步与互斥实验报告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.实验总结通过本次实验,我深刻理解了进程(线程)的同步与互斥,并通过实际操作加深了对这些概念的理解。
同步和互斥是操作系统中非常重要的概念,对于应对资源竞争和提高程序性能具有重要意义。
在实际开发中,我们应该合理使用同步和互斥机制,以确保程序的正确性和并发执行的效率。
操作系统实验一-进程同步
实验一进程同步一、实验目的:分析进程的同步与互斥现象,编程实现经典的进程同步问题——生产者与消费者问题的模拟,进一步加深对进程同步与互斥的理解。
二、实验内容:用C语言实现对生产者与消费者问题的模拟。
实验原理:生产者和消费者是经典的进程同步问题,在这个问题中,生产者不断的向缓冲区中写入数据,而消费者则从缓冲区中读取数据。
生产者进程和消费者对缓冲区的操作是互斥,即当前只能有一个进程对这个缓冲区进行操作,生产者进入操作缓冲区之前,先要看缓冲区是否已满,如果缓冲区已满,则它必须等待消费者进程将数据取出才能写入数据,同样的,消费者进程从缓冲区读取数据之前,也要判断缓冲区是否为空,如果为空,则必须等待生产者进程写入数据才能读取数据。
三、实验准备:1. 实现步骤:(1)分析计算机系统中对资源的分配与释放过程:计算机系统中的每个进程都可以消费或生产某类资源。
当系统中某一进程使用某一资源时,可以看作是消耗,且该进程称为消费者。
而当某个进程释放资源时,则它就相当一个生产者。
(2)定义生产者消费者问题中的各数据结构,并初始化信号量;(3)创建生产者与消费者进程,利用信号量实现生产者与消费者之间的同步与互斥;最后编程实现。
2. 相关函数:在实现的过程中需要用到以下API函数:(1)CreateThread()//该函数创建一个在调用进程的地址空间中执行的线程。
若线程创建成功,将返回该线程的句柄。
函数原型:HANDLE CreateThread (LPSECURITY_ATTRIBUTES lpThreadAttributes, //描述安全性,用NULL表示使用缺省值DWORD dwStackSize, //新线程拥有自己的堆栈,0表示使用缺省值1MB,推荐LPTHREAD_START_ROUTINE lpStartAddress, //新线程的起始地址,放线程函数名称LPVOID lpParameter,//此值被传送到线程函数去作为参数DWORD dwCreationFlags,//允许产生一个暂时挂起的线程,默认是0立即开始执行LPDWORD lpThreadld );//新线程的ID被传到这用法举例:hHandle1 = CreateThread( (LPSECURITY_ATTRIBUTES) NULL,0,(LPTHREAD_START_ROUTINE) ThreadName1,(LPVOID) NULL,0, &dwThreadID1 );(2)CreateMutex()函数可用来创建一个有名或无名的互斥量对象,函数返回值为互斥对象的句柄。
进程同步实验报告
一、实验目的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.实验心得本次实验学习了进程的同步问题,进程是计算机操作系统重要的一个功能,学好进程才能学好其他。
进程同步:实验报告
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.实验名称:进程的同步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 函数。
实验二进程同步实验报告
实验二进程同步一、实验目的:掌握基本的同步算法,理解经典进程同步问题的本质;学习使用Linux的进程同步机制,掌握相关API的使用方法;能利用信号量机制,采用多种同步算法实现不会发生死锁的哲学家进餐程序。
二、实验平台:虚拟机:VMWare12操作系统:kali linux编辑器:Gedit编译器:Gcc三、实验内容:(1)以哲学家进餐模型为依据,在Linux控制台环境下创建5个进程,用semget函数创建一个信号量集(5个信号量,初值为1),模拟哲学家的思考和进餐行为:每一位哲学家饥饿时,先拿起左手筷子,再拿起右手筷子;筷子是临界资源,为每一支筷子定义1个互斥信号量;想拿到筷子需要先对信号量做P操作,使用完释放筷子对信号量做V操作。
伪代码描述:semaphore chopstick[5]={1,1,1,1,1};•第i位哲学家的活动可描述为:do{printf("%d is thinking\n",i);printf("%d is hungry\n",i);wait(chopstick[i]); //拿左筷子wait(chopstick[(i+1) % 5]); //拿右筷子printf("%d is eating\n",i);signal(chopstick[i]); //放左筷子signal(chopstick[(i+1) % 5]); //放右筷子…}while[true];运行该组进程,观察进程是否能一直运行下去,若停滞则发生了什么现象?并分析原因。
(2)解决哲学家进餐问题可采用如下方法:a.仅当哲学家的左、右两只筷子均可用时,才允许他拿起筷子进餐;b.至多只允许有4位哲学家同时去拿左边的筷子,最终能保证至少有一位哲学家能够进餐;c.规定奇数号哲学家先拿起他左手的筷子,然后再拿起他右手的筷子,而偶数号哲学家则先拿起他右手的筷子,然后再拿起他左手的筷子。
操作系统实验报告——进程同步与互斥
操作系统实验报告——进程同步与互斥一、实验内容本实验主要内容是通过编写程序来实现进程的同步与互斥。
具体来说,是通过使用信号量来实现不同进程之间的同步和互斥。
我们将编写两个进程,一个进程负责打印奇数,另一个进程负责打印偶数,两个进程交替打印,要求打印的数字从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个消费者问题,并设计实验验证答:示例程序不能解决多个生产者和消费者的问题,它是解决单个消费者和生产者的。
如果可以就要修改代码,如“二”所说。
二:多个消费者和生产者的问题如上图所示:如果要解决多个生产者和消费者的问题:第一步:分析上图得出了两种关系,分别是异步和同步的关系第二步:异步关系的是生产者和生产者之间的,因为同一时刻只能有一个生产者访问缓冲区,所以我们就可以设置临界资源.获得临界资源的生产者才能把产品放到缓冲区里第三步:同步关系有两个,首先是生产者和缓冲区之间,再是缓冲区和消费者之间。
他们都满足一前一后的关系,即当缓冲区空间未满时,生产者才可以放产品;缓冲区不为空的时候才可以让消费者取出产品消费。
进程同步实验报告
实验三进程的同步一、实验目的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 ,当父进程运行时创建另一个子进程。
操作系统进程同步实验报告
实验三:进程同步实验一、实验任务:(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参数是一些标志位。
操作系统实验报告——进程同步与互斥
《进程同步与互斥》实验报告实验序号: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)。
实验1进程的同步
WaitForSingleObject(hSemaphore_condutor,INFINITE); //等待司机停车的信号
ReleaseSemaphore(hSemaphore_dirver,1,NULL);//让司机开车的信号
}
三、操作界面
cout<<"********************the end pork************************"<<endl;
return 0;
}
//司机线程
DWORD WINAPI ThreadProc_Driver(LPVOID lpParameter)
{while(NUM_PASSENGER_CURRENT<50) //车上未满座
srand(time(0));
NUM_PASSENGER_ON=rand()%10;
cout<<NUM_PASSENGER_ON<<" passengers get on the bus"<<endl;
if(!pork_begin) //如果汽车从起始站出发
{cout<<"no passengers down"<<endl;
pork_begin++;
NUM_PASSENGER_CURRENT=NUM_PASSENGER_ON+NUM_PASSENGER_INITIAL;//起始站上车的人数
}
else
{NUM_PASSENGER_CURRENT=NUM_PASSENGER_CURRENT+NUM_PASSENGER_ON;
北邮大三上-操作系统-进程同步实验报告
操作系统实验二进程同步实验班级: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操作便是一等到空位就顺便占了,而不是我想的等位和占位分离。
而第二个问题自然是不行的,这种操作顺序应该抛弃。
进程同步问题总结报告
进程同步问题总结报告一、问题描述进程同步是操作系统中一个重要的问题,它涉及到多个进程在共享资源时如何正确地访问和操作。
在多进程环境中,如果没有正确的同步机制,会导致诸如竞态条件、死锁等问题。
本报告主要探讨进程同步问题及其解决方案。
二、问题分析1. 竞态条件:当多个进程同时访问共享资源,并且至少有一个进程的操作结果被其他进程的操作所覆盖,就会产生竞态条件。
竞态条件可能会导致数据不一致、系统状态不确定等问题。
2. 死锁:死锁是指两个或多个进程在等待对方释放资源,导致系统无法继续执行的情况。
死锁通常是由于资源分配不当、进程请求资源的顺序不一致等原因造成的。
三、解决方案1. 互斥锁(Mutex):互斥锁是一种最基本的同步机制,它允许一个进程在一段时间内独占共享资源。
当一个进程获得互斥锁后,其他进程就不能再获取锁,直到原进程释放锁。
这样可以避免竞态条件。
2. 信号量(Semaphore):信号量是一个计数器,用于控制对共享资源的访问次数。
信号量的值表示当前可用的共享资源数量。
通过调整信号量的值,可以控制进程对共享资源的访问。
3. 条件变量(Condition Variable):条件变量用于进程间的通信,一个进程可以在条件变量上等待,直到另一个进程通过通知操作唤醒它。
条件变量常与互斥锁、信号量等机制结合使用。
4. 读写锁(Read-Write Lock):读写锁允许多个进程同时读取共享资源,但只允许一个进程写入共享资源。
这可以提高并发性能,特别适用于读操作远多于写操作的情况。
5. 栅栏(Barrier):栅栏是一种同步机制,用于确保多个进程在访问共享资源前都达到某一位置。
栅栏类似于一个检查点,所有进程在到达栅栏前都必须等待,直到所有进程都到达栅栏才继续执行。
四、实验结果我们通过实验验证了这些同步机制的正确性和有效性。
实验中,我们设计了一些多进程程序,模拟了竞态条件和死锁情况,然后使用上述同步机制来解决这些问题。
操作系统进程同步实验报告
操作系统进程同步实验报告本实验旨在通过模拟操作系统中进程的同步问题,加深学生对操作系统中进程同步机制的了解和实践能力。
本次实验分为两个部分,第一个部分是使用信号量实现进程同步,第二个部分是使用管程实现进程同步。
第一部分实验:使用信号量实现进程同步本部分实验的目标是使用信号量来实现进程同步,确保资源的互斥访问。
在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. 实验目的⑴使用EOS的信号量,编程解决生产者 消费者问题,理解进程同步的意义。
⑵调试跟踪EOS信号量的工作过程,理解进程同步的原理。
⑶修改EOS的信号量算法,使之支持等待超时唤醒功能(有限等待),加深理解进程同步的原理。
3. 实验类型验证+设计4. 实验内容⑴准备实验⑵使用EOS的信号量解决生产者-消费者问题⑶调试EOS信号量的工作过程①创建信号量②等待释放信号量③等待信号量(不阻塞)④释放信号量(不唤醒)⑤等待信号量(阻塞)⑥释放信号量(唤醒)⑷修改EOS的信号量算法二、实验环境WindowsXP + EOS集成实验环境三、实验过程1. 设计思路和流程图图4-1.整体试验流程图图4-2.Main 函数流程图、生产者消费、消费者流程图 2. 算法实现3. 需要解决的问题及解答(1). 思考在ps/semaphore.c 文件内的PsWaitForSemaphore 和PsReleaseSemaphore 函数中,为什么要使用原子操作?答:在执行等待信号量和释放信号量的时候,是不允许cpu响应外部中断的,如果此时cpu响应了外部中断,会产生不可预料的结果,无法正常完成原子操作。
(2). 绘制ps/semaphore.c文件内PsWaitForSemaphore和PsReleaseSemaphore函数的流程图。
(3).P143生产者在生产了13号产品后本来要继续生产14号产品,可此时生产者为什么必须等待消费者消费了4号产品后,才能生产14号产品呢?生产者和消费者是怎样使用同步对象来实现该同步过程的呢?答:这是因为临界资源的限制。
临界资源就像产品仓库,只有“产品仓库”空闲生产者才能生产东西,有权向里面放东西。
所以它必须等到消费者,取走产品,“产品空间”(临界资源)空闲时,才继续生产14号产品。
(4). 根据本实验3.3.2节中设置断点和调试的方法,自己设计一个类似的调试方案来验证消费者线程在消费24号产品时会被阻塞,直到生产者线程生产了24号产品后,消费者线程才被唤醒并继续执行的过程。
答:可以按照下面的步骤进行调试(1) 删除所有的断点。
(2) 按F5启动调试。
OS Lab会首先弹出一个调试异常对话框。
(3) 在调试异常对话框中选择“是”,调试会中断。
(4) 在Consumer函数中等待Full信号量的代码行(第173行)WaitForSingleObject(FullSemaphoreHandle, INFINITE); 添加一个断点。
(5) 在“断点”窗口(按Alt+F9打开)中此断点的名称上点击右键。
(6) 在弹出的快捷菜单中选择“条件”。
(7) 在“断点条件”对话框(按F1获得帮助)的表达式编辑框中,输入表达式“i == 24”。
(8) 点击“断点条件”对话框中的“确定”按钮。
(9) 按F5继续调试。
只有当消费者线程尝试消费24号产品时才会在该条件断点处中断。
4. 主要数据结构、实现代码及其说明修改PsWaitForSemaphore函数if (Semaphore->Count>0){Semaphore->Count--;flag=STATUS_SUCCESS;}//如果信号量大于零,说明尚有资源,可以为线程分配elseflag=PspWait(&Semaphore->WaitListHead, Milliseconds);KeEnableInterrupts(IntState); // 原子操作完成,恢复中断。
return flag;}//否则,说明资源数量不够,不能再为线程分配资源,因此要使线程等待修改PsReleaseSemaphore函数if (Semaphore->Count + ReleaseCount > Semaphore->MaximumCount) {Status = STATUS_SEMAPHORE_LIMIT_EXCEEDED;} else {// 记录当前的信号量的值。
if (NULL != PreviousCount) {*PreviousCount = Semaphore->Count;}int mm=Semaphore->Count;// 目前仅实现了标准记录型信号量,每执行一次信号量的释放操作// 只能使信号量的值增加 1。
while ((!ListIsEmpty(&Semaphore->WaitListHead))&&(ReleaseCount)){PspWakeThread(&Semaphore->WaitListHead, STATUS_SUCCESS);PspThreadSchedule();ReleaseCount--;}Semaphore->Count=mm+ReleaseCount;// 可能有线程被唤醒,执行线程调度。
Status = STATUS_SUCCESS;}5. 源程序并附上注释#include "psp.h"VOIDPsInitializeSemaphore(IN PSEMAPHORE Semaphore,IN LONG InitialCount,IN LONG MaximumCount)/*++功能描述:初始化信号量结构体。
参数:Semaphore -- 要初始化的信号量结构体指针。
InitialCount -- 信号量的初始值,不能小于 0 且不能大于 MaximumCount。
MaximumCount -- 信号量的最大值,必须大于 0。
返回值:无。
--*/{ASSERT(InitialCount >= 0 && InitialCount <= MaximumCount && MaximumCount > 0);Semaphore->Count = InitialCount;Semaphore->MaximumCount = MaximumCount;ListInitializeHead(&Semaphore->WaitListHead);}STATUSPsWaitForSemaphore(IN PSEMAPHORE Semaphore,IN ULONG Milliseconds)/*++功能描述:信号量的 Wait 操作(P 操作)。
参数:Semaphore -- Wait 操作的信号量对象。
Milliseconds -- 等待超时上限,单位毫秒。
返回值:STATUS_SUCCESS。
当你修改信号量使之支持超时唤醒功能后,如果等待超时,应该返回 STATUS_TIMEOUT。
--*/{BOOL IntState;STATUS flag;ASSERT(KeGetIntNesting() == 0); // 中断环境下不能调用此函数。
IntState = KeEnableInterrupts(FALSE); // 开始原子操作,禁止中断。
// 目前仅实现了标准记录型信号量,不支持超时唤醒功能,所以 PspWait 函数// 的第二个参数的值只能是 INFINITE。
if (Semaphore->Count>0){Semaphore->Count--;flag=STATUS_SUCCESS;}elseflag=PspWait(&Semaphore->WaitListHead, Milliseconds);KeEnableInterrupts(IntState); // 原子操作完成,恢复中断。
return flag;}STATUSPsReleaseSemaphore(IN PSEMAPHORE Semaphore,IN LONG ReleaseCount,OUT PLONG PreviousCount)/*++功能描述:信号量的 Signal 操作(V 操作)。
参数:Semaphore -- Wait 操作的信号量对象。
ReleaseCount -- 信号量计数增加的数量。
当前只能为 1。
当你修改信号量使之支持超时唤醒功能后,此参数的值能够大于等于 1。
PreviousCount -- 返回信号量计数在增加之前的值。
返回值:如果成功释放信号量,返回 STATUS_SUCCESS。
--*/{STATUS Status;BOOL IntState;IntState = KeEnableInterrupts(FALSE); // 开始原子操作,禁止中断。
if (Semaphore->Count + ReleaseCount > Semaphore->MaximumCount) {Status = STATUS_SEMAPHORE_LIMIT_EXCEEDED;} else {// 记录当前的信号量的值。
if (NULL != PreviousCount) {*PreviousCount = Semaphore->Count;}int mm=Semaphore->Count;// 目前仅实现了标准记录型信号量,每执行一次信号量的释放操作// 只能使信号量的值增加 1。
while ((!ListIsEmpty(&Semaphore->WaitListHead))&&(ReleaseCount)){ PspWakeThread(&Semaphore->WaitListHead, STATUS_SUCCESS);PspThreadSchedule();ReleaseCount--;}Semaphore->Count=mm+ReleaseCount;// 可能有线程被唤醒,执行线程调度。
Status = STATUS_SUCCESS;}KeEnableInterrupts(IntState); // 原子操作完成,恢复中断。
return Status;}//////////////////////////////////////////////////////////////////////////// 下面是和信号量对象类型相关的代码。
// 信号量对象类型指针。
POBJECT_TYPE PspSemaphoreType = NULL;// 用于初始化 semaphore 结构体的参数结构体。
typedef struct _SEM_CREATE_PARAM{LONG InitialCount;LONG MaximumCount;}SEM_CREATE_PARAM, *PSEM_CREATE_PARAM;// semaphore 对象的构造函数,在创建新 semaphore 对象时被调用。