加载中…
个人资料
微博
  • 博客等级：
  • 博客积分：
  • 博客访问：
  • 关注人气：
  • 获赠金笔：0支
  • 赠出金笔：0支
  • 荣誉徽章：
正文 字体大小：大 中 小

[转载]操作系统 读者-写者问题模拟

(2013-11-17 23:39:36)
标签：

转载

 分类： 计蒜机
原文地址：操作系统 读者-写者问题模拟作者：ladya_静候轮回
 读者-写者问题模拟

一、  设计概述

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

读者写者问题可以这样的描述，有一群写者和一群读者，写者在写同一本书，读者也在读这本书，多个读者可以同时读这本书，但是，只能有一个写者在写书，并且，读者必写者优先，也就是说，读者和写者同时提出请求时，读者优先。当读者提出请求时需要有一个互斥操作，另外，需要有一个信号量S来当前是否可操作。

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

与记录型信号量解决读者—写者问题不同，信号量机制它增加了一个限制，即最多允许RN个读者同时读。为此，又引入了一个信号量L,并赋予初值为RN，通过执行wait（L,1,1）操作，来控制读者的数目，每当有一个读者进入时，就要执行wait（L,1,1）操作，使L的值减1。当有RN个读者进入读后，L便减为0，第RN+1 个读者要进入读时，必然会因wait（L,1,1）操作失败而堵塞。对利用信号量来解决读者—写者问题的描述如下：

Var RN integer;L,mx:semaphore: =RN,1；

Begin

Parbegin

  Reader :begin

          Repeat

           Swait（L,1,1）;

           Swait（mx,1,0）;

                  .

           Perform reader operation;

           Ssignal(L,1);

 Until false;

  End

Writer ：begin

         Repeat

Swait(mx ,1,1,l,RN,0);

Perform writer operation;

Ssignal(mx,1);

Until false;

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进程才能进入临界区写。

本设计方案就是通过利用记录型信号量对读者写者问题的解决过程进行模拟演示，形象地阐述记录型信号量机制的工作原理。

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

二 、设计目的与内容

一、实验目的

l. 用信号量来实现读者写者问题。

2 .理解和运用信号量、PV原语、进程间的同步互斥关系等基本知识。二、二、实验内容

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

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

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

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

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

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

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

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

三、设计分析

在Windows 2000 环境下，创建一个包含n 个线程的控制台进程。用这n 个线程来表示n个读者或写者。每个线程按相应测试数据文件的要求，进行读写操作。请用信号量机制分别实现读者优先和写者优先的读者-写者问题。

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

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

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

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

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

将所有的读者和所有的写者分别放进两个等待队列中，当读允许时就让读者队列释放一个或多个读者，当写允许时，释放第一个写者操作。读者写者问题的定义如下：有一个许多进程共享的数据区，这个数据区可以是一个文件或者主存的一块空间；有一些只读取这个数据区的进程（Reader）和一些只往数据区写数据的进程(Writer)，此外还需要满足以下条件：1)任意多个读进程可以同时读这个文件；2) 一次只有一个写进程可以往文件中写；3） 如果一个写进程正在进行操作，禁止任何读进程度文件。 我们需要分两种情况实现该问题：

读优先：要求指一个读者试图进行读操作时，如果这时正有其他读者在进行操作，他可直接开始读操作，而不需要等待。 写优先：一个读者试图进行读操作时，如果有其他写者在等待进行写操作或正在进行写操作，他要等待该写者完成写操作后才开始读操作。

 

 

 

 

 

 

 

 

 

 

 

四. 程序实现  

程序由两部分组成：

1。读者-写者模块：包括系统调用接口，读者-写者活动描述主程序。系统接口主要功能是通过管道向父进程发送系统调用命令，并读取父进程送来的返回值。

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

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

 

初始化系统环境   

 

建立通信管道      

 

启动读者-写者进程   

 

接收系统调用命令

 

解释执行   

      

 

系统初始化模块

管道建立模块

进程启动模块

命令解释模块

Wait()

Signal()

Wakeup()

Block()

主模块
 

 

 

 

 

 

 

 

 

 

 

 

 

 



五、程序调试


测试数据文件格式

测试数据文件包括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释放后最后调用资源。

 



七、心得体会

这一次课程设计，让我体会很深刻。总的感觉，学到了很多知识，特别对于linux有了全面的接触和了解，也开始对linux产生了兴趣，它所开放的源码的确为学计算机的同志们提供了很好的平台。读者-写者问题经典的线程同步问题的一个模型。经过读者写者问题的编写，我对同步机构应用有了深入的了解。懂得了运用信号量实现进程间的互斥。实现了不让共享资源同时修改。用信号量上的原语操作使临界段问题的解决比较简单明了了。读者写者问题的编写，花的时间很多，也学到很多东西。了解支持多道程序的并发操作系统设计中解决资源共享时进程间的同步与互斥的信号量机制。几天的试验，虽然难度有点大，但只要自己花时间去学习，还是会攻克困难的。

总之，每一次课程设计不仅是我们学习的好机会，而且是我们锻炼实际动手能力的平台，虽然有难度的东西总会让人很抵触，比如在课设过程中有很多郁闷的时候，一个小小的错误一不小心就花去了自己一上午的时间，所以在这个过程中能够磨练人的意志与耐心，最后感谢老师的指导与监督。

 

八、参考文献

[1]  谭浩强.C++程序设计北京：清华大学出版社，2004

[2]  汤子瀛. 计算机操作系统[M]. 西安电子科技大学出版社. 2006.9

 

九、辞谢

这次课程设计终于顺利完成了，在设计中遇到了很多编程问题，最后在张爱萍老师的辛勤指导下，终于迎韧而解。同时，在张爱萍老师的身上我学得到很多实用的知识，在次我表示感谢！同时，对给过我帮助的所有同学和各位指导老师再次表示忠心的感谢。



十、附录（源代码）

设计源代码

#include <windows.h>

#include <ctype.h>

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

#include <malloc.h>

#define  MAX_PERSON   100

#define  READER       0 //读者

#define  WRITER       1 //写者

#define  END         -1

#define  R            READER

#define  W            WRITER

 typedef struct _Person

{

HANDLE m_hThread;//定义处理线程的句柄

int    m_nType;//进程类型（读写）

int    m_nStartTime;//开始时间

int    m_nWorkTime;//运行时间

int    m_nID;//进程号

}Person;

 Person g_Persons[MAX_PERSON];

int    g_NumPerson = 0;

long   g_CurrentTime= 0;//基本时间片数

 int    g_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,

};

int    g_NumOfReading = 0;

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

HANDLE g_hReadSemaphore;//读者信号

HANDLE g_hWriteSemaphore;//写者信号

bool finished = false; //所有的读完成

//bool wfinished = false; //所有的写完成

void  CreatePersonList(int *pPersonList);

bool  CreateReader(int StartTime,int WorkTime,int ID);

bool  CreateWriter(int StartTime,int WorkTime,int ID);

DWORD  WINAPI    ReaderProc(LPVOID lpParam);

DWORD  WINAPI    WriterProc(LPVOID lpParam);

int main()

{

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

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

CreatePersonList(g_PersonLists); // Create All the reader and writers

printf("Created all the reader and writern...n");

g_CurrentTime = 0;

while(true)

{

g_CurrentTime++;

Sleep(300); // 300 ms

printf("CurrentTime = %dn",g_CurrentTime);

if(finished) return 0;

} // return 0;

}

void CreatePersonList(int *pPersonLists)

{

int  i=0;

int  *pList = pPersonLists;

bool Ret;

while(pList[0] != END)

{

switch(pList[1])

{

case R:

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

break; case W:

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

break;

}

if(!Ret)

printf("Create Person %d is wrongn",pList[0]);

 pList += 4; // move to next person list

}

}

DWORD  WINAPI ReaderProc(LPVOID lpParam)//读过程

{

Person *pPerson = (Person*)lpParam;

// wait for the start time

while(g_CurrentTime != pPerson->m_nStartTime)

{ }

printf("Reader %d is Requesting ...n",pPerson->m_nID);

printf("nn************************************************n");

// wait for the write request

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("Reader %d is Reading the Shared Buffer...n",pPerson->m_nID);

printf("nn************************************************n");

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

{}

printf("Reader %d is Exit...n",pPerson->m_nID);

printf("nn************************************************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);

return 0;

}

DWORD  WINAPI WriterProc(LPVOID lpParam)

{

Person *pPerson = (Person*)lpParam;

// wait for the start time

while(g_CurrentTime != pPerson->m_nStartTime)

{}

printf("Writer %d is Requesting ...n",pPerson->m_nID);

printf("nn************************************************n");

WaitForSingleObject(g_hWriteSemaphore,INFINITE);

// modify the writer's real start time

pPerson->m_nStartTime = g_CurrentTime;

printf("Writer %d is Writting the Shared Buffer...n",pPerson->m_nID);

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

{}

printf("Writer %d is Exit...n",pPerson->m_nID);

printf("nn************************************************n");

//g_NumOfWriteRequest--;

ReleaseSemaphore(g_hWriteSemaphore,1,NULL);

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

ExitThread(0);

return 0;

}

bool CreateReader(int StartTime,int WorkTime,int ID)

{

DWORD dwThreadID;

if(g_NumPerson >= MAX_PERSON)

return false;

Person *pPerson = &g_Persons[g_NumPerson];

pPerson->m_nID = ID;

pPerson->m_nStartTime = StartTime;

pPerson->m_nWorkTime = WorkTime;

pPerson->m_nType = READER;

g_NumPerson++;

// Create an New Thread

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

if(pPerson->m_hThread == NULL)

return false;

return true;

}

bool CreateWriter(int StartTime,int WorkTime,int ID)

{

DWORD dwThreadID;

if(g_NumPerson >= MAX_PERSON) 

return false;

Person *pPerson  = &g_Persons[g_NumPerson];

pPerson->m_nID  = ID;

pPerson->m_nStartTime = StartTime;

pPerson->m_nWorkTime  = WorkTime;

pPerson->m_nType   = WRITER;

g_NumPerson++;

// Create an New Thread

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

if(pPerson->m_hThread == NULL)

return false;

return true;

}  

喜欢

0

  

新浪BLOG意见反馈留言板　欢迎批评指正

新浪简介 | About Sina | 广告服务 | 联系我们 | 招聘信息 | 网站律师 | SINA English | 产品答疑

Copyright © 1996 - 2022 SINA Corporation, All Rights Reserved

新浪公司 版权所有