读者写者问题.docx

上传人:b****5 文档编号:6275838 上传时间:2023-01-05 格式:DOCX 页数:10 大小:18.41KB
下载 相关 举报
读者写者问题.docx_第1页
第1页 / 共10页
读者写者问题.docx_第2页
第2页 / 共10页
读者写者问题.docx_第3页
第3页 / 共10页
读者写者问题.docx_第4页
第4页 / 共10页
读者写者问题.docx_第5页
第5页 / 共10页
点击查看更多>>
下载资源
资源描述

读者写者问题.docx

《读者写者问题.docx》由会员分享,可在线阅读,更多相关《读者写者问题.docx(10页珍藏版)》请在冰豆网上搜索。

读者写者问题.docx

读者写者问题

读者写者问题

实验报告

 

一、实验目的

●∙∙∙∙∙∙∙用信号量来实现读者写者问题。

●∙∙∙∙∙∙∙学习NachOS的使用方法

●∙∙∙∙∙∙∙理解和运用信号量、PV原语、进程间的同步互斥关系等基本知识。

 

二、实验内容

读者写者问题的定义如下:

有一个许多进程共享的数据区,这个数据区可以是一个文件或者主存的一块空间;有一些只读取这个数据区的进程(Reader)和一些只往数据区写数据的进程(Writer),此外还需要满足以下条件:

(1)   任意多个读进程可以同时读这个文件;

(2)   一次只有一个写进程可以往文件中写;

(3)   如果一个写进程正在进行操作,禁止任何读进程度文件。

实验要求用信号量来实现读者写者问题的调度算法。

实验提供了Semaphore类,该类通过P()、V()两个方法实现了P、V原语的功能。

实验的任务是修改Reader类的Read(int)方法以及Writer类的Write(int)方法。

我们需要分两种情况实现该问题:

Ø∙∙∙∙∙∙∙读优先:

要求指一个读者试图进行读操作时,如果这时正有其他读者在进行操作,他可直接开始读操作,而不需要等待。

Ø∙∙∙∙∙∙∙写优先:

一个读者试图进行读操作时,如果有其他写者在等待进行写操作或正在进行写操作,他要等待该写者完成写操作后才开始读操作。

 

三、问题分析

在Windows2000环境下,创建一个包含n个线程的控制台进程。

用这n个线程来表示n个读者或写者。

每个线程按相应测试数据文件的要求,进行读写操作。

请用信号量机制分别实现读者优先和写者优先的读者-写者问题。

读者-写者问题的读写操作限制:

1)写-写互斥;

2)读-写互斥;

3)读-读允许;

读者优先的附加限制:

如果一个读者申请进行读操作时已有另一读者正在进行读操作,则该读者可直接开始读操作。

写者优先的附加限制:

如果一个读者申请进行读操作时已有另一写者在等待访问共享资源,则该读者必须等到没有写者处于等待状态后才能开始读操作。

运行结果显示要求:

要求在每个线程创建、发出读写操作申请、开始读写操作和结束读写操作时分别显示一行提示信息,以确信所有处理都遵守相应的读写操作限制。

四、实现程序及说明

#include

#include

#include

#include

#include

#include

 

#defineMAX_PERSON100//最多100人

#defineREADER0//读者

#defineWRITER1//写者

#defineEND-1//结束

#defineRREADER

#defineWWRITER

 

typedefstruct_Person

{

HANDLEm_hThread;//定义处理线程的句柄

intm_nType;//进程类型(读写)

intm_nStartTime;//开始时间

intm_nWorkTime;//运行时间

intm_nID;//进程号

}Person;

 

Persong_Persons[MAX_PERSON];

intg_NumPerson=0;

longg_CurrentTime=0;//基本时间片数

 

intg_PersonLists[]={//进程队列

1,W,3,5,

2,W,16,5,

3,R,5,2,

4,W,6,5,

5,R,4,3,

6,R,17,7,

END,

};

 

intg_NumOfReading=0;

intg_NumOfWriteRequest=0;//申请写进程的个数

HANDLEg_hReadSemaphore;//读者信号

HANDLEg_hWriteSemaphore;//写者信号

boolfinished=false;//所有的读完成

//boolwfinished=false;//所有的写完成

 

voidCreatePersonList(int*pPersonList);

 

boolCreateReader(intStartTime,intWorkTime,intID);

boolCreateWriter(intStartTime,intWorkTime,intID);

 

DWORDWINAPIReaderProc(LPVOIDlpParam);

DWORDWINAPIWriterProc(LPVOIDlpParam);

 

 

intmain()

{

g_hReadSemaphore=CreateSemaphore(NULL,1,100,NULL);//创建信号灯,当前可用的资源数为1,最大为100

g_hWriteSemaphore=CreateSemaphore(NULL,1,100,NULL);//创建信号灯,当前可用的资源数为1,最大为100

CreatePersonList(g_PersonLists);//CreateAllthereaderandwriters

printf("Createdallthereaderandwriter\n...\n");

g_CurrentTime=0;

while(true)

{

g_CurrentTime++;

Sleep(300);//300ms

printf("CurrentTime=%d\n",g_CurrentTime);

if(finished)return0;

}

//return0;

}

 

voidCreatePersonList(int*pPersonLists)

{

inti=0;

int*pList=pPersonLists;

boolRet;

while(pList[0]!

=END)

{

switch(pList[1])

{

caseR:

Ret=CreateReader(pList[2],pList[3],pList[0]);//351,w452,523,654

break;

caseW:

Ret=CreateWriter(pList[2],pList[3],pList[0]);

break;

}

if(!

Ret)

printf("CreatePerson%diswrong\n",pList[0]);

pList+=4;//movetonextpersonlist

}

}

 

DWORDWINAPIReaderProc(LPVOIDlpParam)//读过程

{

Person*pPerson=(Person*)lpParam;

//waitforthestarttime

while(g_CurrentTime!

=pPerson->m_nStartTime)

{

//读操作还没有到达执行时间,则等待

}

printf("Reader%disRequesting...\n",pPerson->m_nID);

printf("\n\n************************************************\n");

//waitforthewriterequest

/*while(g_NumOfWriteRequest!

=0)

{

//g_NumOfWriteRequest!

=0表示现在正在写,不能读

}*/

//该语句在写者优先的时候是认为写者优先级高于读者,在有写者的时候读者需//要等候,而在读者优先的时候,不用判断是否存在写者,有读者时即开始读操//作。

WaitForSingleObject(g_hReadSemaphore,INFINITE);//等待g_hReadSemaphore读信号,即当g_hReadSemaphore有信号时等待结束相当于p操作

if(g_NumOfReading==0)

{

WaitForSingleObject(g_hWriteSemaphore,INFINITE);//当第一个读者到了,如果g_hWriteSemaphore信号灯灭了,说明有写者再写,读者必须等待。

即互斥写操作

}

 

g_NumOfReading++;

ReleaseSemaphore(g_hReadSemaphore,1,NULL);//还有读者,但是允许下一个读进程读取,相当于V操作//modifythereader'srealstarttime

pPerson->m_nStartTime=g_CurrentTime;

printf("Reader%disReadingtheSharedBuffer...\n",pPerson->m_nID);

printf("\n\n************************************************\n");

while(g_CurrentTime<=pPerson->m_nStartTime+pPerson->m_nWorkTime)

{

//..performreadoperations

}

printf("Reader%disExit...\n",pPerson->m_nID);

printf("\n\n************************************************\n");

WaitForSingleObject(g_hReadSemaphore,INFINITE);

g_NumOfReading--;

if(g_NumOfReading==0)

{

ReleaseSemaphore(g_hWriteSemaphore,1,NULL);//此时没有读者,可以写

}

ReleaseSemaphore(g_hReadSemaphore,1,NULL);

if(pPerson->m_nID==4)finished=true;//所有的读写完成

ExitThread(0);

return0;

}

 

DWORDWINAPIWriterProc(LPVOIDlpParam)

{

Person*pPerson=(Person*)lpParam;

//waitforthestarttime

while(g_CurrentTime!

=pPerson->m_nStartTime)

{

}

printf("Writer%disRequesting...\n",pPerson->m_nID);

printf("\n\n************************************************\n");

//g_NumOfWriteRequest++;

 

//在写者优先的时候需要用自加来初始信号值,而在读者优先的时是通过读者操作来控制信号值

 

WaitForSingleObject(g_hWriteSemaphore,INFINITE);

//modifythewriter'srealstarttime

pPerson->m_nStartTime=g_CurrentTime;

printf("Writer%disWrittingtheSharedBuffer...\n",pPerson->m_nID);

while(g_CurrentTime<=pPerson->m_nStartTime+pPerson->m_nWorkTime)

{

//..performwriteoperations

}

printf("Writer%disExit...\n",pPerson->m_nID);

printf("\n\n************************************************\n");

//g_NumOfWriteRequest--;

ReleaseSemaphore(g_hWriteSemaphore,1,NULL);

if(pPerson->m_nID==4)finished=true;//所有的读写完成

ExitThread(0);

return0;

}

 

boolCreateReader(intStartTime,intWorkTime,intID)

{

DWORDdwThreadID;

if(g_NumPerson>=MAX_PERSON)

returnfalse;

Person*pPerson=&g_Persons[g_NumPerson];

pPerson->m_nID=ID;

pPerson->m_nStartTime=StartTime;

pPerson->m_nWorkTime=WorkTime;

pPerson->m_nType=READER;

g_NumPerson++;

//CreateanNewThread

pPerson->m_hThread=CreateThread(NULL,0,ReaderProc,(LPVOID)pPerson,0,&dwThreadID);

if(pPerson->m_hThread==NULL)

returnfalse;

returntrue;

}

 

boolCreateWriter(intStartTime,intWorkTime,intID)

{

DWORDdwThreadID;

if(g_NumPerson>=MAX_PERSON)

returnfalse;

Person*pPerson=&g_Persons[g_NumPerson];

pPerson->m_nID=ID;

pPerson->m_nStartTime=StartTime;

pPerson->m_nWorkTime=WorkTime;

pPerson->m_nType=WRITER;

g_NumPerson++;

//CreateanNewThread

pPerson->m_hThread=CreateThread(NULL,0,WriterProc,(LPVOID)pPerson,0,&dwThreadID);

if(pPerson->m_hThread==NULL)

returnfalse;

returntrue;

}

五、实验结果

测试数据文件格式

测试数据文件包括n行测试数据,分别描述创建的n个线程是读者还是写者,以及读写

操作的开始时间和持续时间。

每行测试数据包括四个字段,各字段间用空格分隔。

第一字段

为一个正整数,表示线程序号。

第二字段表示相应线程角色,R表示读者是,W表示写者。

第三字段为一个正数,表示读写操作的开始时间。

线程创建后,延时相应时间(单位为秒)

后发出对共享资源的读写申请。

第四字段为一个正数,表示读写操作的持续时间。

当线程读

写申请成功后,开始对共享资源的读写操作,该操作持续相应时间后结束,并释放共享资源。

下面是一个测试数据文件的例子:

1,W,3,5,

2,W,16,5,

3,R,5,2,

4,W,6,5,

5,R,4,3,

6,R,17,7,

试验结果如下图:

 

六、结果分析和讨论

在读者写者同时在队列中等待申请资时,读者优先调用资源。

而且如果一个读者申请进行读操作时已有另一读者正在进行读操作,则该读者可直接开始读操作,即读读允许。

进程1是W操作,在时间3时进入队列,运行时间是5,在它进入时没有进程占用资源,它既占用资源;知道它释放资源,等候的进程有3,4,5;

进程2是R操作,在时间16时进入队列,运行时间是5,在它进入时进程4占用资源,它等待资源,当4释放时占用资源;

进程3是R操作,在时间5时进入队列,运行时间是2,在它进入时进程1占用资源,它等待资源,当进程1释放资源后,由于读者优先,进程3,5同时调运资源;

进程4是W操作,在时间6时进入队列,运行时间是5,在它进入时进程1占用资源,它等待资源,当进程1释放资源后,由于读者优先,进程3,5占用资源,它依然等待,直到进程3,5都结束;

进程5是R操作,在时间4时进入队列,运行时间是3,在它进入时进程1占用资源,它等待资源,当进程1释放资源后,由于读者优先,进程3,5同时调运资源;

进程6是R操作,在时间17时进入队列,运行时间是7,在它进入时进程2占用资源,它等待进程2释放后最后调用资源。

 

七、收获感想和体会

经过读者写者问题的编写,我对同步机构应用有了深入的了解。

懂得了运用信号量实现进程间的互斥。

实现了不让共享资源同时修改。

用信号量上的原语操作使临界段问题的解决比较简单明了了。

展开阅读全文
相关资源
猜你喜欢
相关搜索

当前位置:首页 > 小学教育 > 其它课程

copyright@ 2008-2022 冰豆网网站版权所有

经营许可证编号:鄂ICP备2022015515号-1