实验一进程同步与互斥
一、实验目的
1．掌握基本的同步与互斥算法，理解生产者消费者模型。
2．学习使用Windows 2000/XP中基本的同步对象，掌握相关API的使用方法。
3．了解Windows 2000/XP中多线程的并发执行机制，实现进程的同步与互斥。
二、实验内容及要求
1．实验内容
以生产者/消费者模型为依据，在Windows 2000环境下创建一个控制台进程，在该进程
中创建n个线程模拟生产者和消费者，实现进程(线程)的同步与互斥。
2．实验要求
, 学习并理解生产者/消费者模型及其同步/互斥规则；
, 学习了解Windows同步对象及其特性；
, 熟悉实验环境，掌握相关API的使用方法；
, 设计程序，实现生产者/消费者进程(线程)的同步与互斥；
, 提交实验报告。
三、相关知识介绍
1．同步对象
同步对象是指Windows中用于实现同步与互斥的实体，包括信号量(Semaphore)、互斥量(Mutex)、临界区(Critical Section)和事件(Events)等。本实验中使用到信号量、互斥量和临
界区三个同步对象。
同步对象的使用步骤：
, 创建/初始化同步对象。
, 请求同步对象，进入临界区(互斥量上锁)。
, 释放同步对象(互斥量解锁)。
这些对象在一个线程中创建，在其他线程中都可以使用，实现同步与互斥。
2．相关API的功能及使用
我们利用Windows SDK提供的API编程实现实验题目要求，而VC中包含有Windows SDK的所有工具和定义。要使用这些API，需要包含堆这些函数进行说明的SDK头文件——最常见的是Windows.h(特殊的API调用还需要包含其他头文件)。
下面给出的是本实验使用到的API的功能和使用方法简单介绍。
(1) CreateThread
, 功能——创建一个在调用进程的地址空间中执行的线程
, 格式
HANDLE CreateThread( LPSECURITY_ATTRIBUTES lpThreadAttributes,
DWORD dwStackSize,
LPTHREAD_START_ROUTINE lpStartAddress,
LPVOID lpParamiter,
DWORD dwCreationFlags,
Lpdword lpThread );
, 参数说明
lpThreadAttributes——指向一个LPSECURITY_ATTRIBUTES(新线程的安全性描述符)。
dwStackSize——定义原始堆栈大小。
lpStartAddress——指向使用LPTHRAED_START_ROUTINE类型定义的函数。
lpParamiter——定义一个给进程传递参数的指针。 dwCreationFlags——定义控制线程创建的附加标志。 lpThread——保存线程标志符(32位)
(2) CreateMutex
, 功能——创建一个命名或匿名的互斥量对象 , 格式
HANDLE CreateMutex(LPSECURITY_ATTRIBUTES lpMutexAttributes,
BOOL bInitialOwner,
LPCTSTR lpName);
, 参数说明
lpMutexAttributes——必须取值NULL。
bInitialOwner——指示当前线程是否马上拥有该互斥量(即马上加锁)。
lpName——互斥量名称。
(3) CreateSemaphore
, 功能——创建一个命名或匿名的信号量对象 , 格式
HANDLE CreateSemaphore(LPSECURITY_ATTRIBUTES lpSemaphoreAttributes, LONG lInitialCount,
LONG lMaximumCount,
LPCTSTR lpName );
, 参数说明
lpSemaphoreAttributes——必须取值NULL。 lInitialCount——信号量的初始值。该值大于0，但小于lMaximumCount指定的最大值。
lMaximumCount——信号量的最大值。
lpName——信号量名称。
(4) WaitForSingleObject
, 功能——使程序处于等待状态，直到信号量hHandle出现(即其值大于等于1)或超过
规定的等待时间
, 格式
DWORD WaitForSingleObject(HANDLE hHandle, DWORD dwMilliseconds);
, 参数说明
hHandle——信号量指针。
dwMilliseconds——等待的最长时间(INFINITE为无限等待)。 (5) ReleaseSemaphore
, 功能——对指定信号量加上一个指定大小的量。成功执行则返回非0值
, 格式
BOOL ReleaseSemaphore(HANDLE hSemaphore,
LONG lReleaseCount,
LPLONG lppreviousCount );
, 参数说明
hSemaphore——信号量指针。
lReleaseCount——信号量的增量。
lppreviousCount——保存信号量当前值。 (6) ReleaseMutex
, 功能——打开互斥锁，即把互斥量加1。成功调用则返回0
, 格式
BOOL ReleaseMutex(HANDLE hMutex);
, 参数说明
hMutex——互斥量指针。
(7) InitializeCriticalSection
, 功能——初始化临界区对象
, 格式
VOID InitializeCriticalSection(LPCRITICAL_SECTION lpCriticalSection); , 参数说明
lpCriticalSection——指向临界区对象的指针。 (8) EnterCriticalSection , 功能——等待指定临界区对象的所有权 , 格式
VOID enterCriticalSection(LPCRITICAL_SECTION lpCriticalSection);
, 参数说明
lpCriticalSection——指向临界区对象的指针。 (9) LeaveCriticalSection , 功能——释放指定临界区对象的所有权 , 格式
VOID LeaveCriticalSection(LPCRITICAL_SECTION lpCriticalSection);
, 参数说明
lpCriticalSection——指向临界区对象的指针。
四、实验示例(方法、步骤与例程)
1．测试用例文件
测试用例文件用于描述各线程的有关信息，该文件内容及格式如下：
3
1 P 3
2 P 4
3 C
4 1
4 P 2
5 C 3 1 2 4
说明：第一行给出的是程序中设置的临界区个数；其余各行是各进程信息。
每行中的数据之间用Tab键分隔。
第一列(除第一行外)：线程号。
第二列：P——生产者，C——消费者。
第三列：线程在生产和消费前的休眠时间，单位为秒。
第四及以后各列：消费的产品所对应的生产者线程号。
2．数据结构
(1) 用整型数组Buffer_Critical表示缓冲区。 (2) 用自定义结构ThreadInfo记录一条线程信息，多个线程对应一个ThreadInfo数组。
(3) 通过如下同步对象实现互斥：
, 设一个互斥量h-mutex，实现生产者在查询和保留缓冲区的下一个空位置时进
行互斥。
, 设置h_Semaphore[MAX_THREAD_NUM]信号量数组表示相应产品已经生产，实现生产者与消费者之间的同步。同时，用表示空缓冲区树木的信号量
empty_semephore指示是否存在空位置，实现类似的同步，以便开始下一个产品的生产。
, 设置临界区对象数组PC_Critical[MAX_BUFFER_NUM]实现每个缓冲区上消费者之间的互斥。
3．程序结构
为了方便，程序结构用如下的文字予以描述。
(1) 主函数
(2) 初始化缓冲区、消费请求队列及部分同步对象
(3) 提取线程信息
(4) 完成线程相关同步对象的初始化
(5) 创建线程，模拟生产者和消费者
(6) 等待所有线程结束
(7) 程序结束
(8) 消费者
(9) 有无消费请求？有，则继续(10)；无，则转(16)
(10) 此请求可满足？可满足，转(11)；否，则阻塞，再转(10)
(11) 确定产品位置
(12) 此产品正被消费？是，则阻塞，再转(12)；否，则转(13)
(13) 进入临界区(请求同一产品的消费者之间互斥)
(14) 消费产品，并判断是否应该释放产品所占缓冲区
(15) 退出临界区，转(9)
(16) 结束消费者线程
(17) 生产者
(18) 存在空缓冲区？有，则继续(19)；无，则阻塞，再转(18)
(19) 另一生产者在写？否，则转(20)；是，则阻塞，再转(19)
(20) 进入临界区(请求同一产品的生产者之间互斥)
(21) 在缓冲区中为本线程产品分配空间
(22) 退出临界区
(23) 写入产品到分配的缓冲区空间中
(24) 结束生产者线程
4．示例程序
//**************************R_WP1.CPP******************************* //
#include
#include
#include
#include
#include
//本程序允许的最大临界区数
#define MAX_BUFFER_NUM 10
//秒到微秒的乘法因子
#define INTE_PER_SEC 1000
//生产和消费进程总数
#define MAX_THREAD_NUM 64
//定义记录在测试文件中的线程参数数据结构
struct ThreadInfo
{int serial;
char entity;
double delay;
int thread_request[MAX_THREAD_NUM];
int n_request;
};
//全局变量定义
//临界区对象的声明，用于管理缓冲区的互斥访问 CRITICAL_SECTION PC_Critical[MAX_BUFFER_NUM];
int Buffer_ Critical[MAX_BUFFER_NUM]; //缓冲区声明 HANDLE
h_Thread[MAX_THREAD_NUM]; //存储线程句柄的数组
ThreadInfoThread_info[MAX_THREAD_NUM]; //线程信息数组 HANDLE
empty_semephore; //信号量 HANDLE h_mutex; //互斥量 DWORD n_Thread=0; //实际线程数目 DWORD n_Buffer_or_Critical; //实际缓冲区/临界区数目HANDLE h_semephore[MAX_THREAD_NUM]; //生产者允许消费的信号量
//生产、消费及辅助函数的声明
void Produce(void *p);
void Consume(void *p);
bool IfInOtherRequest(int);
int FindProducePosition();
int FindBufferPosition(int);
int main(void)
{DWORD wait_for_all;
ifstream inFile;
//初始化缓冲区
for(int i=0;i Buffer_Critical[i]=-1; //初始化各线程的请求队列 for(int j=0;j { for(int k=0;j Threa_Info[j].thread_request[k]=1; Thread_Info[j].n_request=0; } //初始化临界区对象 for(int i=0;i InitializeCriticalSection(&PC_Critical[i]); //打开输入文件，提取线程信息 inFile.open(“test.txt”); //从文件中获得实际缓冲区数目 inFile>>n_Buffer_or_Critical; inFile.get(); printf(“输入文件是:\n”); //回显获得的缓冲区数目 printf(“%d \n”,(int)n_Buffer_or_Critical); //提取各线程信息到相应的数据结构中 while(inFile) { inFile>>Thread_Info[n_Thread].serial; inFile>>Thread_Info[n_Thread].entity; inFile>>Thread_Info[n_Thread].delay; char c; inFile.get(c); while(c!=’\n’&&!inFile.eof()) { inFile>> Thread_Info[n_Thread].thread_request[Thread_Info[n_Thread].n_request ++]; inFile.get(c); } n_Thread++; } //回显获得的线程信息，便于确认正确性 for(j=0;j<(int)n_Thread;j++) {int Temp_serial=Thread_Info[j].serial; char Temp_entity=Thread_Info[j].entity; double Temp_delay=Thread_Info[j].delay; printf(“ \n thread%2d %c %f”,Temp_serial,Temp_entity,Temp_delay); int Temp_request=Thread_Info[j].n_request; for(int k=0;k printf(“ %d ”,Thread_In[j].thread_request[k]); cout< } printf(“\n\n”); //创建模拟过程中必要的信号量 empty_semaphore=CreateSemaphore(NULL,n_Buffer_or_Critical, n_Buffer_or_Critical, “semephore_for_empty”); h_mutex=CreateMutex(NULL,FALSE, “mutex_for_update”); //用线程ID为产品读写时所使用的同步信号量命名 for(j=0;j<(int)n_Thread;j++) {std::string lp=”semephore_for_produce”; int temp=j; while(temp) {char c=(char)(temp%10); lp+=c; temp/=10; } h_Semaphore[j+1]=CreateSemaphore(NULL,0,n_Thread,lp.c_str()); } //创建生产者和消费者线程 for(i=0;i<(int)n_Thread;i++) {if(Thread_Info[i].entity==’P’) h_Thread[i]=CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)(Produce),&( Thread_Info[i]),0,NULL); h_Thread[i]=CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)(Consume), &(Thread_Info[i]),0,NULL); } //主程序等待各个线程的动作结束 wait_for_all=WaitForMultipleObjects(n_Thread,h_Thread,TRUE,-1); printf(“ \n \nALL Producer and Consumer have finished their work, \n”); printf(“Press any key to quit!\n”); return 0; } //确认是否还有对同一产品的消费请求未执行 bool IfInOtherRequest(int req) {for(int i=0;i for(int j=0;j if(Thread_Info[i].thread_request[j]==req) return TRUE; return FALSE; } //找出当前可以进行产品生产的空缓冲区位置 int FindProducePosition() {int EmptyPosition; for(int i=0;i if(Buffer_Critical[i]=-1) {EmptyPosition=i; //用下列特殊值表示本缓冲区正处于被写状态 Buffer_Critical[i]=-2; Break; } return EmptyPosition; } //找出当前需要生产者生产的产品的位置 int FindBufferPosition(int ProPos) {int TempPos; for(int i=0;i if(Buffer_Critical[i]=ProPos) {TempPos=i; Break; } return TempPos; } //生产者线程 void Produce(void *p) {//局部变量声明 DWORD wait_for_semaphore,wait_for_mutex,m_delay; int m_serial; //获得本线程信息 m_serial=((ThreadInfo*)(p))->serial; m_delay=(DWORD)(((ThreadInfo*)(p))->delay *INTE_PER_SEC); Sleep(m_delay); //开始请求生产 printf(“Producer %2d sends the produce require.\n”,m_serial); //确认有空缓冲区，同时把空位置数empty减1，用于生产/消费同步 wait_for_semaphore=WaitForSingleObject(empty_semaphore,-1); //互斥访问下一个用于生产的空临界区，实现写写互斥 wait_for_mutex= WaitForSingleObject(h_mutex,-1); int ProducePos=FindProducePosition(); ReleaseMutex(h_mutex); //生产者在获得的空位置做标记，以下的写操作在生产者之间可以并发执行//在核心生产步骤中，程序用生产者的ID作为产品编号供消费者识别 printf(“Producer %2d begin to produce at position %2d.\n”,m_seri al,ProducePos); Buffer_Critical[ProducePos]=m_serial; printf(“Producer %2d finish producing :\n”,m_serial); printf(“Position[ %2d ]:%3d \n”,ProducePos,Buffer_Critical[ProducePos]); //实现读写同步 ReleaseSemaphore(h_Semaphore[m_serial],n_Thread,NULL); } //消费者线程 void Consume(void *p) {//局部变量声明 DWORD wait_for_semaphore,m_delay; int m_serial,m_requestNum; //消费者序列号和请求的数目 int m_thread_request[MAX_THREAD_NUM]//本消费线程的请求队列//提取本线程的信息 m_serial=((ThreadInfo*)(p))->serial; m_delay=(DWORD)(((ThreadInfo*)(p))->delay *INTE_PER_SEC); m_requestNum=((ThreadInfo*))->n_request; for(int i=0;i m_thread_request[i]=((ThreadInfo*)(p))->thread_request[i]; Sleep(m_delay); //循环进行所需产品的生产 for(i=0;i {//请求消费下一个产品 printf(“ Consumer %2d re quest to consume %2d product\n”,m_serial,m_thread_request[i]); //若生产者未生产，则等待； //若生产了，允许消费数目为-1；实现读写同步 wait_for_semaphore=WaitForSingleObject(h_semaphore[m_thread_request[ i]],-1) //查询所需产品在缓冲区的号 int BufferPos=FindBufferPosition(m_thread_request[i]); //开始消费，读读互斥 //进入临界区消费，消费完毕通知其他消费者自己的请求已满足 //若产品消费完，应做相应处理，并给出提示 //相应处理是指把相应的缓冲区清空，并增加代表空缓冲区的信号量 EnterCriticalSection(&PC_Critical[BufferPos]); Printf(“Consumer%2d begin to cosume %2d product\n”,m_serial,m_thread_request[i]); ((ThreadInfo*)(p))->thread_request[i]=-1; if(!IfInOtherRequest(m_thread_request[i])) {Buffer_Critical[BufferPos]=-1; //标记缓冲区为空 printf(“Consumer%2d finish consuming %2d:\n”, m_serial,m_thread_request[i]); printf(“position[%2d]:%3d\n”,BufferPos,Buffer_Critical[BufferPos]); ReleaseSemaphore(empty_semaphore,1,NULL); } else {printf(“Consumer %2d finish consuming product %2d\n”, m_serial,m_thread_request[i]); } //离开临界区 LeaveCriticalSection(&PC_Critical[BufferPos]); } } 学习中心： 专业： 年级：年春/秋季 学号： 学生： 题目：进程同步与互斥生产者-消费者问题 1.谈谈你对本课程学习过程中的心得体会与建议？ 转眼间，学习了一个学期的计算机操作系统课程即将结束。在这个学期中，通过老师的悉心教导，让我深切地体会到了计算机操作系统的一些原理和具体操作过程。在学习操作系统之前，我只是很肤浅地认为操作系统只是单纯地讲一些关于计算机方面的操作应用，并不了解其中的具体操作过程 1.1设计思路 在这次设计中定义的多个缓冲区不是环形循环的，并且不需要按序访问。其中生产者可以把产品放到某一个空缓冲区中，消费者只能消费被指定生产者生产的产品。本设计在测试用例文件中指定了所有生产和消费的需求，并规定当共享缓冲区的数据满足了所有有关它的消费需求后，此共享才可以作为空闲空间允许新的生产者使用。 本设计在为生产者分配缓冲区时各生产者之间必须互斥，此后各个生产者的具体生产活动可以并发。而消费者之间只有在对同一个产品进行消费时才需要互斥，它们在消费过程结束时需要判断该消费者对象是否已经消费完毕并释放缓冲区的空间。 1.2程序流程图 1.3基本内容 在设计程序时主要有三个主体部分、三个辅助函数和一个数据结构。 其中主体部分为一个主函数main（），用于初始化缓冲区和各个同步对象，并完成线程信息的读入，最后根据该组的线程记录启动模拟线程，并等待所有线程的运 Y 行结束后退出程序； 生产者函数Produce（）和消费者函数Consume（），生产者和消费者函数运行于线程中完成对缓冲区的读、写动作，根据此处生产消费的模型的特点，生产者和消费者之间通过使用同步对象实现了生产和消费的同步与互斥，是本实验的核心所在。 另外三个辅助性函数被生产者和消费者函数调用，是上述生产和消费函数中对缓冲区进行的一系列处理。 3)在实现本程序的消费生产模型时，具体的通过如下同步对象实现互斥： ①设一个互斥量h_mutex，以实现生产者在查询和保留缓冲区内的下一个位置时进行互斥。 ②每一个生产者用一个信号量与其消费者同步，通过设置h_Semaphore[MAX_THREAD_NUM]信号量 ③数组实现，该组信号量用于相应的产品已产生。同时用一个表示空缓冲区 实验二（2）进程同步 一、实验目的 1、生产者-消费者问题是很经典很具有代表性的进程同步问题，计算机中的很多同步问题都可抽象为生产者-消费者问题，通过本实验的练习，希望能加深学生对进程同步问题的认识与理解。 2、熟悉VC的使用，培养和提高学生的分析问题、解决问题的能力。 二、实验内容及其要求 1．实验内容 以生产者/消费者模型为依据，创建一个控制台进程，在该进程中创建n个线程模拟生产者和消费者，实现进程(线程)的同步与互斥。 2．实验要求 学习并理解生产者/消费者模型及其同步/互斥规则；设计程序，实现生产者/消费者进程(线程)的同步与互斥； 三、实验算法分析 1、实验程序的结构图（流程图）； 2、数据结构及信号量定义的说明； (1) CreateThread ●功能——创建一个在调用进程的地址空间中执行的线程 ●格式 HANDLE CreateThread( LPSECURITY_ATTRIBUTES lpThreadAttributes, DWORD dwStackSize, LPTHREAD_START_ROUTINE lpStartAddress, LPVOID lpParamiter, DWORD dwCreationFlags, Lpdword lpThread ); ●参数说明 lpThreadAttributes——指向一个LPSECURITY_ATTRIBUTES(新线程的安全性描述符)。dwStackSize——定义原始堆栈大小。 lpStartAddress——指向使用LPTHRAED_START_ROUTINE类型定义的函数。 lpParamiter——定义一个给进程传递参数的指针。 dwCreationFlags——定义控制线程创建的附加标志。 lpThread——保存线程标志符(32位) (2) CreateMutex ●功能——创建一个命名或匿名的互斥量对象 ●格式 HANDLE CreateMutex(LPSECURITY_ATTRIBUTES lpMutexAttributes, BOOL bInitialOwner, LPCTSTR lpName); bInitialOwner——指示当前线程是否马上拥有该互斥量(即马 ●参数说明 lpMutexAttributes——必须取值NULL。上加锁)。 lpName——互斥量名称。 (3) CreateSemaphore ●功能——创建一个命名或匿名的信号量对象 ●格式 HANDLE CreateSemaphore(LPSECURITY_ATTRIBUTES lpSemaphoreAttributes, LONG lInitialCount, LONG lMaximumCount, LPCTSTR lpName ); ●参数说明 lpSemaphoreAttributes——必须取值NULL。 实验报告 1、实验名称 进程间的互斥和同步 2、小组成员：姓名+学号 3、实验目的 Linux命名信号量实现进程间的互斥和同步 4、实验背景知识 进程同步也是进程之间直接的制约关系，是为完成某种任务而建立的两个或多个线程，这个线程需要在某些位置上协调他们的工作次序而等待、传递信息所产生的制约关系。进程间的直接制约关系来源于他们之间的合作。比如说进程A需要从缓冲区读取进程B产生的信息，当缓冲区为空时，进程B因为读取不到信息而被阻塞。而当进程A产生信息放入缓冲区时，进程B才会被唤醒。 进程互斥是进程之间的间接制约关系。当一个进程进入临界区使用临界资源时，另一个进程必须等待。只有当使用临界资源的进程退出临界区后，这个进程才会解除阻塞状态。比如进程B需要访问打印机，但此时进程A占有了打印机，进程B会被阻塞，直到进程A释放了打印机资源,进程B才可以继续执行。 5、实验步骤演示 大概步骤： 先进行单次同步，把信号量先初始化为0，创建一个命名信号量，设置信号捕捉处理代码，安装捕捉信号；其次使用信号量进行同步和互斥的操作。 详细步骤： 1.创建一个命名信号量，sem = sem_open(SEM_NAME, OPEN_FLAG, OPEN_MODE, INIT_V); 2.创建子进程，pid = fork(); 3.V操作，sem_post(sem); 4.P操作，sem_wait(sem); 5.等待子进程结束，wait(&status); 6.删掉在系统创建的信号量，sem_unlink(SEM_NAME); 7.彻底销毁打开的信号量，sem_close(sem); 8.信号捕捉处理，static void myhandler(void); 9.迭代同步,两个信号量，开始时一个为1，一个为0，一个进程执行完换另一个执行； 10.安装捕捉信号，signal(SIGINT,(void *)myhandler ); 11.创建一个命名信号量：sem1 = sem_open(SEM_NAME1, OPEN_FLAG, OPEN_MODE, 1);sem2 = sem_open(SEM_NAME2, OPEN_FLAG, OPEN_MODE, 0); 12.创建子进程，pid = fork(); 13.if(0 == pid) P操作：sem_wait(sem1); V操作：sem_post(sem2); 14.if(0 < pid) P操作：sem_wait(sem2); V操作：sem_post(sem1); 15.static void mysem(char *str) { int i = 0; //P操作 sem_wait(sem); while('\0' != str[i]) { printf("%c\n", str[i++]); sleep(1); } //V操作 sem_post(sem); } 进程排斥,在临界区设置PV操作 16.创建一个命名信号量，sem = sem_open(SEM_NAME, OPEN_FLAG, OPEN_MODE, INIT_V); 17.if(0 == pid) { mysem("abcd"); } 18.if(0 < pid) { mysem("1234"); //等待子进程结束 wait(&status); //删掉在系统创建的信号量 sem_unlink(SEM_NAME); //彻底销毁打开的信号量 sem_close(sem); } 说明： 命名信号量不带内存共享,编译时要带库文件-lpthread或-lrt 第三章 一．选择题(50题) 1.以下_B__操作系统中的技术是用来解决进程同步的。 A.管道 B.管程 C.通道 2.以下_B__不是操作系统的进程通信手段。 A.管道 B.原语 C.套接字 D.文件映射 3.如果有3个进程共享同一程序段，而且每次最多允许两个进程进入该程序段，则信号量的初值应设置为_B__。 4.设有4个进程共享一个资源，如果每次只允许一个进程使用该资源，则用P、V操作管理时信号量S的可能取值是_C__。 ,2,1,0，-1 ,1,0，-1，-2 C. 1,0，-1，-2，-3 ,3，2,1,0 5.下面有关进程的描述，是正确的__A__。 A.进程执行的相对速度不能由进程自己来控制 B.进程利用信号量的P、V 操作可以交换大量的信息 C.并发进程在访问共享资源时，不可能出现与时间有关的错误 、V操作不是原语操作 6.信号灯可以用来实现进程之间的_B__。 A.调度 B.同步与互斥 C.同步 D.互斥 7.对于两个并发进程都想进入临界区，设互斥信号量为S，若某时S=0，表示_B__。 A.没有进程进入临界区 B.有1个进程进入了临界区 C. 有2个进程进入了临界区 D. 有1个进程进入了临界区并且另一个进程正等待进入 8. 信箱通信是一种_B__方式 A.直接通信 B.间接通信 C.低级通信 D.信号量 9.以下关于临界区的说法，是正确的_C__。 A.对于临界区，最重要的是判断哪个进程先进入 B.若进程A已进入临界区，而进程B的优先级高于进程A，则进程B可以 打断进程A而自己进入临界区 C. 信号量的初值非负，在其上只能做PV操作 D.两个互斥进程在临界区内，对共享变量的操作是相同的 10. 并发是指_C__。 A.可平行执行的进程 B.可先后执行的进程 C.可同时执行的进程 D.不可中断的进程 11. 临界区是_C__。 A.一个缓冲区 B.一段数据区 C.一段程序 D.栈 12．进程在处理机上执行，它们的关系是_C__。 A.进程之间无关，系统是封闭的 B.进程之间相互依赖相互制约 C.进程之间可能有关，也可能无关 D.以上都不对 13. 在消息缓冲通信中，消息队列是一种__A__资源。 A.临界 B.共享 C.永久 D.可剥夺 14. 以下关于P、V操作的描述正确的是__D_。 A.机器指令 B. 系统调用 C.高级通信原语 D.低级通信原语 15.当对信号量进行V源语操作之后，_C__。 A.当S＜0，进程继续执行 B.当S＞0，要唤醒一个就绪进程 C. 当S＜＝ 0，要唤醒一个阻塞进程 D. 当S＜＝0，要唤醒一个就绪 16.对临界区的正确论述是__D_。 A.临界区是指进程中用于实现进程互斥的那段代码 B. 临界区是指进程中用于实现进程同步的那段代码 C. 临界区是指进程中用于实现进程通信的那段代码 D. 临界区是指进程中访问临界资源的那段代码 17. __A__不是进程之间的通信方式。 A.过程调用 B.消息传递 C.共享存储器 D.信箱通信 18. 同步是指进程之间逻辑上的__A__关系。 山东大学操作系统实验报告4进程同步实验 计算机科学与技术学院实验报告 实验题目：实验四、进程同步实验学号： 日期：20120409 班级：计基地12 姓名： 实验目的： 加深对并发协作进程同步与互斥概念的理解，观察和体验并发进程同步与互斥 操作的效果，分析与研究经典进程同步与互斥问题的实际解决方案。了解 Linux 系统中 IPC 进程同步工具的用法，练习并发协作进程的同步与互斥操作的编程与调试技术。 实验内容： 抽烟者问题。假设一个系统中有三个抽烟者进程，每个抽烟者不断地卷烟并抽烟。抽烟者卷起并抽掉一颗烟需要有三种材料：烟草、纸和胶水。一个抽烟者有烟草，一个有纸，另一个有胶水。系统中还有两个供应者进程，它们无限地供应所有三种材料，但每次仅轮流提供三种材料中的两种。得到缺失的两种材料的抽烟者在卷起并抽掉一颗烟后会发信号通知供应者，让它继续提供另外的两种材料。这一过程重复进行。请用以上介绍的 IPC 同步机制编程，实现该问题要求的功能。 硬件环境： 处理器：Intel? Core?i3-2350M CPU @ 2.30GHz ×4 图形：Intel? Sandybridge Mobile x86/MMX/SSE2 内存：4G 操作系统：32位 磁盘：20.1 GB 软件环境： ubuntu13.04 实验步骤： （1）新建定义了producer和consumer共用的IPC函数原型和变量的ipc.h文件。 （2）新建ipc.c文件，编写producer和consumer 共用的IPC的具体相应函数。 （3）新建Producer文件，首先定义producer 的一些行为，利用系统调用，建立共享内存区域，设定其长度并获取共享内存的首地址。然后设定生产者互斥与同步的信号灯，并为他们设置相应的初值。当有生产者进程在运行而其他生产者请求时，相应的信号灯就会阻止他，当共享内存区域已满时，信号等也会提示生产者不能再往共享内存中放入内容。 （4）新建Consumer文件，定义consumer的一些行为，利用系统调用来创建共享内存区域，并设定他的长度并获取共享内存的首地址。然后设定消费者互斥与同步的信号灯，并为他们设置相应的初值。当有消费进程在运行而其他消费者请求时，相应的信号灯就会阻止它，当共享内存区域已空时，信号等也会提示生产者不能再从共享内存中取出相应的内容。 运行的消费者应该与相应的生产者对应起来，只有这样运行结果才会正确。 进程的同步互斥实验 实验目的 1、进一步认识并发执行的实质 2、分析进程竞争资源的现象，学习解决进程同步互斥的方法 实验内容 1、编写程序，使用相关函数实现父子进程对共享文件的同步互斥访问。 2、修改程序，观察对临界资源访问的互斥控制的作用。 实验基础 一、临界资源的互斥访问 为了实现多进程对临界资源的互斥访问，一个进程访问临界资源的典型程序段类似如下形式： { ………. 进入区 临界区; 退出区 其余代码; ………} 其中，进入区中判断资源是否可用，如果可用，则资源数量减1，进程进入临界区；否则进程阻塞等待。退出区中资源数量加1，唤醒阻塞等待该资源的进程。进入区和退出区都是原子操作。 操作系统中，通常用信号量来实现进入区和退出区，即P操作和V操作。为了实现用户程序中对某些资源的同步互斥访问，操作系统也提供了一些函数接口，功能类似于对特定临界区的进入区和退出区功能。 二、相关的系统调用 （1）lockf(files,function,size) ：用作锁定文件的某些段或者整个文件。 函数原型： #include 那么lockf的调用进程将被阻塞直到该区域解锁。 通过使用lockf函数，可实现多进程对共享文件进行互斥访问。进程的实现中，必须使得每个进程在使用文件前对文件加锁，使用文件后解锁。 （2）open：打开一个文件 函数原型：#include 操作系统 实验报告 哈尔滨工程大学 计算机科学与技术学院 一、实验概述 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; }//如果信号量大于零，说明尚有资源，可以为线程分配 else flag=PspWait(&Semaphore->WaitListHead, Milliseconds); KeEnableInterrupts(IntState); // 原子操作完成，恢复中断。 return flag; }//否则，说明资源数量不够，不能再为线程分配资源，因此要使线程等待 修改PsReleaseSemaphore函数 if (Semaphore->Count + ReleaseCount > Semaphore->MaximumCount) { 实验四：进程的管道通信 实验题目 进程的管道通信 实验目的 加深对进程概念的理解，明确进程和程序的区别。学习进程创建的过程，进一步认识进程并发执行的实质。分析进程争用资源的现象，学习解决进程互斥的方法。学习解决进程同步的方法。掌握Linux系统中进程间通过管道通信的具体实现 实验内容 使用系统调用pipe()建立一条管道，系统调用fork()分别创建两个子进程，它们分别向管道写一句话，如： Child process1 is sending a message! Child process2 is sending a message! 父进程分别从管道读出来自两个子进程的信息，显示在屏幕上。 当然，仅仅通过屏幕上输出这两句话还不能说明实现了进程的管道通信，为了能够更好的证明和显示出进程的同步互斥和通信，在其中要加入必要的跟踪条件，如一定的输出语句等，来反映程序的并发执行情况 实验要求 这是一个设计型实验，要求自行、独立编制程序。两个子进程要并发执行。实现管道的互斥使用。当一个子进程正在对管道进行写操 作时，另一个欲写入管道的子进程必须等待。使用系统调用lockf(fd[1],1,0)实现对管道的加锁操作，用lockf(fd[1],0,0)解除对管道的锁定。实现父子进程的同步，当父进程试图从一空管道中读取数据时，便进入等待状态，直到子进程将数据写入管道返回后，才将其唤醒。 为了清楚的反应进程的同步，在子进程完成相应的操作后，调用sleep()函数睡眠一段时间（程序中定为3s）。父进程先执行wait()函数，当有子进程执行完毕后，会得到子进程的返回结果并清理子进程。若子进程没执行完，父进程一直执行wait()进行监听，知道有一个子进程执行完成为僵尸进程。 程序中用到的系统调用 因为程序时在linux系统上进行编写的，所以其中要利用到相关的linux提供的系统调用。 所用到的系统调用包含在如下头文件中。 #include 进程间互斥与同步 实验内容： 编写算法，实现进程间对临界资源的互斥访问以及进程间的同步关系。 实验要求： 1、要求进程互斥使用文本文件； 2、假定文本文件txt1最大可写入30个字符； 3、写满后复制进程将文本文件的内容复制到另一个文本文件txt2中（无长度限制）。 4、复制进程复制完毕写入进程可再重新写入，重复执行3，4，直到给出停止命令。 5、实现进程间的同步和互斥。 代码： #include sem_b.sem_num=0; sem_b.sem_op=1; sem_b.sem_flg=SEM_UNDO; if(semop(sem_id,&sem_b,1)==-1) { cout<<"error"< 实验三进程的同步 一、实验目的 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）创建两个子进程： 进程同步与互斥 进程的PV操作 在操作系统中，P、V操作是进程管理中的难点。这是1968年荷兰人Dijkstra 给出的一种解决并发进程间互斥和同步关系的通用方法。 1. P、V操作的意义 定义了信号量及其上的P操作和V操作，来实现并发进程间的同步和互斥，甚至可以用来管理资源的分配。P、V操作因交换的信息量少，属于进程的低级通信。 2. 什么是信号量？ 信号量（semaphore）是由一个值和一个指针构成的数据结构。值为整型变 量，表示信息量的值；指针指向进程控制块（PCB）队列的队头，表示等待该信号量的下一个进程。如下图所示。 信号量的一般结构及PCB队列 信号量的值与相应资源的使用情况有关。当它的值大于0时，表示当前可用资源的数量；当它的值小于0时，其绝对值表示等待使用该资源的进程个数。注意，信号量的初值不能为负，且其值只能由P、V操作来改变。 3. P、V操作的含义 P、V操作由P操作原语和V操作原语组成（原语是不可中断的过程），对信号量S进行操作，具体定义如下： P（S）： ①将信号量S的值减1，即S=S-1； ②如果S≥0，则该进程继续执行；否则该进程状态置为阻塞状态，进程PCB 排入信号量PCB队列末尾，放弃CPU，等待V操作的执行。 V（S）： ①将信号量S的值加1，即S=S+1； ②如果S≤0，释放信号量队列中第一个PCB所对应的进程，将进程状态由阻塞态改为就绪态。执行V操作的进程继续执行。 一般来说，信号量S≥0时，S表示可用资源的数量。执行一次P操作意味着请求分配一个单位资源，因此S的值减1；当S<0时，表示已经没有可用资源，请求者必须等待别的进程释放该类资源，它才能运行下去。而执行一个V操作意味着释放一个单位资源，因此S的值加1；若S≤0，表示有某些进程正在等待该资源，因此要唤醒一个阻塞状态的进程，使之成为就绪状态。 4. 利用信号量和P、V操作实现进程互斥 一般地，n个进程利用信号量和P、V操作实现进程互斥的一般模型如下： 进程P 1进程P 2 ……进程Pn …… …… …… P（S）； P（S）； P（S）； 临界区；临界区；临界区； V（S）； V（S）； V（S）； …… …… …… …… 其中S是互斥信号量，初值为1。 使用P、V操作实现进程互斥时应该注意的问题是： （1）每个程序中，用户实现互斥的P、V操作必须成对出现，先做P操作，进临界区，后做V操作，出临界区。若有多个分支，要认真检查P、V操作的成对性。 （2）P、V操作应分别紧靠临界区的头尾部，临界区的代码应尽可能短，不能有死循环。 （3）互斥信号量的初值一般为1。 由于用于互斥的信号量sem与所有的并发进程有关，所以称之为公有信号量。公有信号量的值反映了公有资源的数量。只要把临界区置于P(sem)和V(sem) 操作系统实验报告 课程名称操作系统实验名称进程（线程）的同步与互斥成绩 学生姓名作业君专业软件工程班级、学号 同组者姓名无实验日期2020 一、实验题目:进程（线程）的同步与互斥 二、实验目的： 自行编制模拟程序，通过形象化的状态显示，加深理解进程的概念、进程之间的状态转换及其所带来的PCB内容、组织的变化，理解进程与其PCB间的一一对应关系。1．掌握基本的同步与互斥算法，理解生产者消费者模型。 2．学习使用Windows中基本的同步对象，掌握相关API的使用方法。 3．了解Windows中多线程的并发执行机制，实现进程的同步与互斥 三、实验内容与要求： 1．实验内容 以生产者/消费者模型为依据，在Windows 环境下创建一个控制台进程，在该进程中创建n个线程模拟生产者和消费者，实现进程(线程)的同步与互斥。 2．实验要求 学习并理解生产者/消费者模型及其同步/互斥规则； 学习了解Windows同步对象及其特性； 熟悉实验环境，掌握相关API的使用方法； 设计程序，实现生产者/消费者进程(线程)的同步与互斥； 四、算法描述（含数据结构定义）或流程图 #include #define MAX_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; //判断程序能否继续执行的逻辑值 int g_buffer[SIZE_OF_BUFFER]; //缓冲区是个循环队列 HANDLE g_hMutex; //公有信号量，用于线程间的互斥HANDLE g_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); 实验进程同步与互斥 一、实验目的 1．掌握基本的同步与互斥算法，理解生产者消费者模型。 2．学习使用Windows 2000/XP中基本的同步对象，掌握相关API的使用方法。 3．了解Windows 2000/XP中多线程的并发执行机制，实现进程的同步与互斥。 二、实验内容及要求 1．实验内容 以生产者/消费者模型为依据，在Windows 2000环境下创建一个控制台进程，在该进程中创建n个线程模拟生产者和消费者，实现进程(线程)的同步与互斥。 2．实验要求 ●学习并理解生产者/消费者模型及其同步/互斥规则； ●学习了解Windows同步对象及其特性； ●熟悉实验环境，掌握相关API的使用方法； ●设计程序，实现生产者/消费者进程(线程)的同步与互斥； ●提交实验报告。 三、相关知识介绍 1．同步对象 同步对象是指Windows中用于实现同步与互斥的实体，包括信号量(Semaphore)、互斥量(Mutex)、临界区(Critical Section)和事件(Events)等。本实验中使用到信号量、互斥量和临界区三个同步对象。 同步对象的使用步骤： ●创建/初始化同步对象。 ●请求同步对象，进入临界区(互斥量上锁)。 ●释放同步对象(互斥量解锁)。 这些对象在一个线程中创建，在其他线程中都可以使用，实现同步与互斥。 2．相关API的功能及使用 我们利用Windows SDK提供的API编程实现实验题目要求，而VC中包含有Windows SDK的所有工具和定义。要使用这些API，需要包含堆这些函数进行说明的SDK头文件——最常见的是Windows.h(特殊的API调用还需要包含其他头文件)。 下面给出的是本实验使用到的API的功能和使用方法简单介绍。 (1) CreateThread ●功能——创建一个在调用进程的地址空间中执行的线程 ●格式 HANDLE CreateThread( LPSECURITY_ATTRIBUTES lpThreadAttributes, DWORD dwStackSize, LPTHREAD_START_ROUTINE lpStartAddress, 实验二进程同步 一、实验目的： 掌握基本的同步算法，理解经典进程同步问题的本质；学习使用Linux的进程同步机制，掌握相关API的使用方法；能利用信号量机制，采用多种同步算法实现不会发生死锁的哲学家进餐程序。 二、实验平台： 虚拟机：VMWare9以上 操作系统：以上 编辑器：Gedit | Vim 编译器：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］); 当哲学家的左、右两只筷子均可用时，才允许他拿起筷子进餐；b.至多只允许有4位哲学家同时去拿左边的筷子，最终能保证至少有一位哲学家能够进餐；c.规定奇数号哲学家先拿起他左手的筷子，然后再拿起他右手的筷子，而偶数号哲学家则先拿起他右手的筷子，然后再拿起他左手的筷子。方法a在示例程序中给出，请用方法b和c写出不会发生死锁的哲学家进餐程序。 （3）设计程序，实现生产者/消费者进程(线程)的同步与互斥。在该程序中创建4个进程（或线程）模拟生产者和消费者，实现进程(线程)的同步与互斥。 实验一进程同步与互斥 一、实验目的 1．掌握基本的同步与互斥算法，理解生产者消费者模型。 2．学习使用Windows 2000/XP中基本的同步对象，掌握相关API的使用方法。 3．了解Windows 2000/XP中多线程的并发执行机制，实现进程的同步与互斥。 二、实验内容及要求 1．实验内容 以生产者/消费者模型为依据，在Windows 2000环境下创建一个控制台进程，在该进程 中创建n个线程模拟生产者和消费者，实现进程(线程)的同步与互斥。 2．实验要求 , 学习并理解生产者/消费者模型及其同步/互斥规则； , 学习了解Windows同步对象及其特性； , 熟悉实验环境，掌握相关API的使用方法； , 设计程序，实现生产者/消费者进程(线程)的同步与互斥； , 提交实验报告。 三、相关知识介绍 1．同步对象 同步对象是指Windows中用于实现同步与互斥的实体，包括信号量(Semaphore)、互斥量(Mutex)、临界区(Critical Section)和事件(Events)等。本实验中使用到信号量、互斥量和临 界区三个同步对象。 同步对象的使用步骤： , 创建/初始化同步对象。 , 请求同步对象，进入临界区(互斥量上锁)。 , 释放同步对象(互斥量解锁)。 这些对象在一个线程中创建，在其他线程中都可以使用，实现同步与互斥。 2．相关API的功能及使用 我们利用Windows SDK提供的API编程实现实验题目要求，而VC中包含有Windows SDK的所有工具和定义。要使用这些API，需要包含堆这些函数进行说明的SDK头文件——最常见的是Windows.h(特殊的API调用还需要包含其他头文件)。 下面给出的是本实验使用到的API的功能和使用方法简单介绍。 (1) CreateThread , 功能——创建一个在调用进程的地址空间中执行的线程 , 格式 HANDLE CreateThread( LPSECURITY_ATTRIBUTES lpThreadAttributes, DWORD dwStackSize, LPTHREAD_START_ROUTINE lpStartAddress, LPVOID lpParamiter, DWORD dwCreationFlags, Lpdword lpThread ); , 参数说明 lpThreadAttributes——指向一个LPSECURITY_ATTRIBUTES(新线程的安全性描述符)。进程同步机制与互斥-生产者消费者问题
实验二(1)进程同步
进程间的同步和互斥-
进程同步与通信作业习题与答案
山东大学操作系统实验报告4进程同步实验
进程同步互斥1
进程的同步实验报告汇总
操作系统实验-进程同步与互斥
计算机操作系统_进程间互斥与同步
进程同步实验报告
进程同步与互斥汇总
进程(线程)的同步与互斥实验报告
Windows下进程同步与互斥
实验二进程同步实验
实验一 进程同步与互斥
相关主题
文本预览