读者写者.docx

读者写者.docx

《读者写者.docx》由会员分享，可在线阅读，更多相关《读者写者.docx（12页珍藏版）》请在冰豆网上搜索。

读者写者

实现读者写者（Reader-WriterProblem）问题

数据结构与模块说明

1.设计概述

所谓读者写着问题，是指保证一个writer进程必须与其他进程互斥地访问共享对象的同步问题。

读者写者问题可以这样的描述，有一群写者和一群读者，写者在写同一本书，读者也在读这本书，多个读者可以同时读这本书，但是，只能有一个写者在写书，并且，读者必写者优先，也就是说，读者和写者同时提出请求时，读者优先。

当读者提出请求时需要有一个互斥操作，另外，需要有一个信号量S来当前是否可操作。

信号量机制是支持多道程序的并发操作系统设计中解决资源共享时进程间的同步与互斥的重要机制，而读者写者则是这一机制的一个经典范例。

与记录型信号量解决读者—写者问题不同，信号量机制它增加了一个限制，即最多允许RN个读者同时读。

为此，又引入了一个信号量L,并赋予初值为RN，通过执行wait（L,1,1）操作，来控制读者的数目，每当有一个读者进入时，就要执行wait（L,1,1）操作，使L的值减1。

当有RN个读者进入读后，L便减为0，第RN+1个读者要进入读时，必然会因wait（L,1,1）操作失败而堵塞。

对利用信号量来解决读者—写者问题的描述如下：

VarRNinteger;L,mx:

semaphore:

=RN,1；

Begin

Parbegin

 Reader:

begin

         Repeat

          Swait（L,1,1）;

          Swait（mx,1,0）;

                 .

          Performreaderoperation;

          Ssignal（L,1）;

 Untilfalse;

 End

Writer：

begin

        Repeat

Swait（mx,1,1,l,RN,0）;

Performwriteroperation;

Ssignal（mx,1）;

Untilfalse;

End

Parend

End

 其中，Swait（mx,1,0）语句起着开关作用，只要无Writer进程进入些，mx=1，reader进程就都可以进入读。

但是要一旦有Writer进程进入写时，其MX=0，则任何reader进程就都无法进入读。

Swait（mx,1,1,l,RN,0）语句表示仅当既无Write进程在写（mx=1），又无reader进程在读（L=RN）时，writer进程才能进入临界区写。

2.具体编程实现

读者-写者的读写限制（包括读者优先和写者优先）

1）写-写互斥，即不能有两个写者同时进行写操作

2）读-写互斥，即不能同时有一个读者在读，同时却有一个写者在写

3）读读允许，即可以有2个以上的读者同时读

将所有的读者和所有的写者分别放进两个等待队列中，当读允许时就让读者队列释放一个或多个读者，当写允许时，释放第一个写者操作。

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

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

1）任意多个读进程可以同时读这个文件；

2）一次只有一个写进程可以往文件中写；

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

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

读优先：

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

写优先：

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

程序由三部分组成：

1．读者模块：

包括系统调用接口，读者活动描述主程序。

系统接口主要功能是通过管道向父进程发送系统调用命令，并读取父进程送来的返回值。

2．写者模块：

包括系统调用接口，写者活动描述主程序。

读者-写者活动程序根据临界资源的共享，互斥原则编制。

3.主控模块：

主控模块实现系统初始化系统调用命令接收与解释执行，系统调用功能的实现（包括信号量机制），及读者-写者活动过程记录与显示。

3.运行结果与测试

测试数据文件包括n行测试数据，分别描述创建的n个线程是读者还是写者，以及读写操作的开始时间和持续时间。

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

第一字段为一个正整数，表示线程序号。

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

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

线程创建后，延时相应时间（单位为秒）后发出对共享资源的读写申请。

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

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

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

 1,W，4,5,

2,W,16,4,

3,R,5,2,

4,W,6,5,

5,R,4,3,

4.源代码;

#include

#include

#include

#include

#include

#include

#defineMAX_PERSON100

#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,4,5,2,W,16,4,3,R,5,2,

4,W,6,5,5,R,4,3,

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）;//创建信号灯，当前可用的资源数为，最大为

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

CreatePersonList（g_PersonLists）;//CreateAllthereaderandwriters

printf（"已经创建好所有读者写者\n...\n"）;

g_CurrentTime=0;

while（true）

{

g_CurrentTime++;

Sleep（300）;//300ms

printf（"CurrentTime=%d\n",g_CurrentTime）;

if（finished）return0;

system（"pause"）;

}//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（"读者%d正在请求...\n",pPerson->m_nID）;

printf（"\n\n************************************************\n"）;

//waitforthewriterequest

WaitForSingleObject（g_hReadSemaphore,INFINITE）;if（g_NumOfReading==0）

{

WaitForSingleObject（g_hWriteSemaphore,INFINITE）;}

g_NumOfReading++;

ReleaseSemaphore（g_hReadSemaphore,1,NULL）;

pPerson->m_nStartTime=g_CurrentTime;

printf（"读者%d正在读...\n",pPerson->m_nID）;

printf（"\n\n************************************************\n"）;

while（g_CurrentTime<=pPerson->m_nStartTime+pPerson->m_nWorkTime）

{}

printf（"读者%d退出...\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（"写者%d正在请求...\n",pPerson->m_nID）;

printf（"\n\n************************************************\n"）;

WaitForSingleObject（g_hWriteSemaphore,INFINITE）;

//modifythewriter'srealstarttime

pPerson->m_nStartTime=g_CurrentTime;

printf（"写者%d正在写...\n",pPerson->m_nID）;

while（g_CurrentTime<=pPerson->m_nStartTime+pPerson->m_nWorkTime）

{}

printf（"写者%d退出...\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;

}