读者与写着报告.docx
《读者与写着报告.docx》由会员分享，可在线阅读，更多相关《读者与写着报告.docx（17页珍藏版）》请在冰点文库上搜索。
读者与写着报告
《操作系统专题实训》
课程设计报告
设计题目：
读者写者问题
学号：
姓名：
专业：
计算机科学与技术
班级：
08网络班
一、设计目的
通过实现经典的读者写者问题，巩固对线程及其同步机制的学习效果。
加深对相关基本概念的理解。
并学习如何将基本原理和实际设计有机的结合。
二、设计要求
在Windows2000/XP环境下，使用多线程和信号量机制实现经典的读者写者问题，每个线程代表一个读者或一个写者。
每个线程按相应测试数据文件的要求，进行读写操作。
请用信号量机制分别实现读者优先和写者优先的读者-写者问题。
读者-写者问题的读写操作限制：
（1）写-写互斥，即不能有两个写者同时进行写操作
（2）读-写互斥，即不能同时有一个读者在读，同时却有一个写者在写
（3）读-读允许，即可以有二个以上的读者同时读
读者优先的附加限制：
如果一个读者申请进行读操作时已有另一读者正在进行读操作，则该读者可直接开始读操作。
写者优先的附加限制：
如果一个读者申请进行读操作时已有另一写者在等待访问共享资源，则该读者必须等到没有写者处于等待状态后才能开始读操作。
运行结果显示要求：
要求在每个线程创建、发出读写操作申请、开始读写操作和结束读写操作时分别显示一行提示信息，以确信所有处理都遵守相应的读写操作限制。
三、设计内容与步骤
1、临界区：
CRITICAL_SECTIONRP_Write;//临界区
CRITICAL_SECTIONcs_Write;
CRITICAL_SECTIONcs_Read;
2、定义线程结构:
structThreadInfo
{
intThreadhao;
charThreadClass;
doubleThreadStartTime;
doubleThreadRunTime;
};
3、互斥对象
创建互斥对象
CreateMutex（NULL,FALSE,"mutex_for_readcount"）;
参数含义如下：
NULL表示创建带有默认安全性的内核对象
FALSE表示该互斥对象没有被任何线程所拥有
mutex_for_readcount是为内核对象赋予名字。
释放互斥信号
ReleaseMutex（h_Mutex）;
对资源具有访问权的线程不再需要访问此资源而要离开时，必须通过ReleaseMutex（）函数来释放其拥有的互斥对象
4、创建读者线程
CreateThread（NULL,0,\（LPTHREAD_START_ROUTINE）（R_ReaderThread）,\&thread_info[i],0,&thread_ID）;
5、等待函数
WaitForMultipleObjects（n_thread,h_Thread,TRUE,-1）;
等待函数可使线程自愿进入等待状态，直到一个特定的内核对象变为已通知状态为止
6、测试数据格式
1r35
2w45
3r52
4r65
5w53
四、算法描述
将所有的读者和所有的写者分别放进两个等待队列中，当读允许时就让读者队列释放一个或多个读者，当写允许时，释放第一个写者操作。
读者优先：
如果没有写者正在操作，则读者不需要等待，用一个整型变量readcount记录当前的读者数目，用于确定是否释放写者线程，（当readcout=0时，说明所有的读者都已经读完，释放一个写者线程），每个读者开始读之前都要修改readcount,为了互斥的实现对readcount的修改，需要一个互斥对象Mutex来实现互斥。
另外，为了实现写-写互斥，需要一个临界区对象write,当写者发出写的请求时，必须先得到临界区对象的所有权。
通过这种方法，可以实现读写互斥，当readcount=1时，（即第一个读者的到来时，），读者线程也必须申请临界区对象的所有权.
当读者拥有临界区的所有权，写者都阻塞在临界区对象write上。
当写者拥有临界区对象所有权时，第一个判断完readcount==1后，其余的读者由于等待对readcount的判断，阻塞在Mutex上！
写者优先：
写者优先和读者优先有相同之处，不同的地方在：
一旦有一个写者到来时，应该尽快让写者进行写，如果有一个写者在等待，则新到的读者操作不能读操作，为此添加一个整型变量writecount,记录写者的数目，当writecount=0时才可以释放读者进行读操作！
为了实现对全局变量writecount的互斥访问，设置了一个互斥对象Mutex3。
为了实现写者优先，设置一个临界区对象read,当有写者在写或等待时，读者必须阻塞在临界区对象read上。
读者除了要一个全局变量readcount实现操作上的互斥外，还需要一个互斥对象对阻塞在read这一个过程实现互斥，这两个互斥对象分别为mutex1和mutex2。
五、程序设计
#include
#include
#include
intreadcount=0;//读者数目
intwritecount=0;//写者数目
CRITICAL_SECTIONRP_Write;//临界区
CRITICAL_SECTIONcs_Write;
CRITICAL_SECTIONcs_Read;
structThreadInfo//线程信息
{
intThreadhao;//线程序号
charThreadClass;//线程类别
doubleThreadStartTime;//线程开始时间
doubleThreadRunTime;//线程读写持续时间
};
voidReaderFun（char*file）;//读者优先函数
voidR_ReaderThread（void*p）;//处理读者优先读者线程
voidR_WriterThread（void*p）;//处理读者优先写者线程
voidWriterFun（char*file）;
voidW_ReaderThread（void*p）;
voidW_WriterThread（void*p）;
intmain（）//主函数
{
charselect;
while（true）
{
cout<<"***************本程序实现读者-写者问题*******\n"<cout<<"1:
读者优先"<cout<<"2:
写者优先"<cout<<"3:
退出"<cout<<"\n*********************************************"<cout<<"请选择要进行的操作:
"<do
{
cin>>select;
if（select!
='1'&&select!
='2'&&select!
='3'）
cout<<"你操作有误，请重试！
"<}while（select!
='1'&&select!
='2'&&select!
='3'）;
system（"cls"）;
if（select=='3'）
return0;//退出
elseif（select=='1'）//调用读者优先
ReaderFun（"peizhi.txt"）;
elseif（select=='2'）//调用写者优先
WriterFun（"peizhi.txt"）;
cout<<"\n是否还有继续?
1.继续2.退出"<do
{
cin>>select;
if（select!
='1'&&select!
='2'）
cout<<"你操作有误，请重试！
"<}while（select!
='1'&&select!
='2'）;
if（select=='2'）
return0;//退出
system（"cls"）;
}
return0;
}
//读者优先函数
voidReaderFun（char*file）
{
DWORDn_thread=0;//线程数初值为0
DWORDthread_ID;//线程ID
DWORDwait_for_all;//等待所有线程结束
//临界资源
HANDLEh_Mutex;
//互斥对象（h_Mutex）确保线程拥有对单个资源的互斥访问权
h_Mutex=CreateMutex（NULL,FALSE,"mutex_for_readcount"）;
HANDLEh_Thread[64];//线程对象数组，最大64
ThreadInfothread_info[64];
readcount=0;
InitializeCriticalSection（&RP_Write）;//初始化临界区
ifstreaminFile;
inFile.open（file）;
cout<<"读者优先:
\n"<while（inFile）
{
//读入每一个读者、写者的信息
inFile>>thread_info[n_thread].Threadhao
>>thread_info[n_thread].ThreadClass
>>thread_info[n_thread].ThreadStartTime
>>thread_info[n_thread].ThreadRunTime;
if（-1==inFile.get（））
break;
n_thread++;//线程数加一
}
for（inti=0;i<（int）（n_thread）;i++）
{
if（thread_info[i].ThreadClass=='r'）
//创建读者线程
h_Thread[i]=CreateThread（NULL,0,\
（LPTHREAD_START_ROUTINE）（R_ReaderThread）,\
&thread_info[i],0,&thread_ID）;
else
//创建写者线程
h_Thread[i]=CreateThread（NULL,0,\
（LPTHREAD_START_ROUTINE）（R_WriterThread）,\
&thread_info[i],0,&thread_ID）;
}
wait_for_all=WaitForMultipleObjects（n_thread,h_Thread,TRUE,-1）;
cout<<"所有的读者和写者线程完成操作."<}
//读者优先-----读者线程
voidR_ReaderThread（void*p）
{
//互斥变量
HANDLEh_Mutex;
h_Mutex=OpenMutex（MUTEX_ALL_ACCESS,FALSE,"mutex_for_readcount"）;
DWORDwait_for_mutex;//等待互斥变量所有权
DWORDm_delay;//延迟时间
DWORDm_ThreadRunTime;//读文件持续时间
intm_Threadhao;//线程序号
m_Threadhao=（（ThreadInfo*）（p））->Threadhao;
m_delay=（DWORD）（（（ThreadInfo*）（p））->ThreadStartTime*100）;
m_ThreadRunTime=（DWORD）（（（ThreadInfo*）（p））->ThreadRunTime*100）;
Sleep（m_delay）;//延迟等待
cout<<"读者线程"<//等待互斥对象通知
wait_for_mutex=WaitForSingleObject（h_Mutex,-1）;//等待互斥信号，保证对readcount的访问、
//修改互斥
readcount++;//读者数目加一
if（readcount==1）
EnterCriticalSection（&RP_Write）;//禁止写者进入
ReleaseMutex（h_Mutex）;//释放互斥对象，允许下个读者继续读：
//读文件
cout<<"读者线程"<Sleep（m_ThreadRunTime）;
//退出线程
cout<<"读者线程"<wait_for_mutex=WaitForSingleObject（h_Mutex,-1）;//等待互斥信号，保证对readcount的访问、修改互斥
readcount--;//读者数目减少
if（readcount==0）
LeaveCriticalSection（&RP_Write）;//如果所有读者读完，唤醒写者
ReleaseMutex（h_Mutex）;//释放互斥信号
}
//读者优先-----写者线程
voidR_WriterThread（void*p）
{
DWORDm_delay;//延迟时间
DWORDm_ThreadRunTime;//读文件持续时间
intm_Threadhao;//线程序号
//从参数中获得信息
m_Threadhao=（（ThreadInfo*）（p））->Threadhao;
m_delay=（DWORD）（（（ThreadInfo*）（p））->ThreadStartTime*100）;
m_ThreadRunTime=（DWORD）（（（ThreadInfo*）（p））->ThreadRunTime*100）;
Sleep（m_delay）;//延迟等待
cout<<"写者线程"<EnterCriticalSection（&RP_Write）;//禁止下一位写者进入
//写文件
cout<<"写者线程"<Sleep（m_ThreadRunTime）;
//退出线程
cout<<"写者线程"<LeaveCriticalSection（&RP_Write）;//如果所有读者读完，唤醒写者
}
//写者优先处理函数
voidWriterFun（char*file）
{
DWORDn_thread=0;//线程数目
DWORDthread_ID;//线程ID
DWORDwait_for_all;//等待所有线程结束
//互斥对象
HANDLEh_Mutex1,h_Mutex2,h_Mutex3;
h_Mutex1=CreateMutex（NULL,FALSE,"mutex_for_writecount"）;
h_Mutex2=CreateMutex（NULL,FALSE,"mutex_for_readcount"）;
h_Mutex3=CreateMutex（NULL,FALSE,"mutex_for_read"）;
//线程对象数组
HANDLEh_Thread[64];
ThreadInfothread_info[64];
readcount=0;//初始化readcount
InitializeCriticalSection（&cs_Write）;//初始化临界区
InitializeCriticalSection（&cs_Read）;
ifstreaminFile;
inFile.open（file）;//打开文件
cout<<"写者优先:
\n"<while（inFile）
{//读入每一个读者、写者的信息
inFile>>thread_info[n_thread].Threadhao
>>thread_info[n_thread].ThreadClass
>>thread_info[n_thread].ThreadStartTime
>>thread_info[n_thread].ThreadRunTime;
if（-1==inFile.get（））
break;
n_thread++;//线程数加一
}
for（inti=0;i<（int）（n_thread）;i++）
{
if（thread_info[i].ThreadClass=='r'）
//创建读者线程
h_Thread[i]=CreateThread（NULL,0,\
（LPTHREAD_START_ROUTINE）（W_ReaderThread）,\
&thread_info[i],0,&thread_ID）;
else
//创建写者线程
h_Thread[i]=CreateThread（NULL,0,\
（LPTHREAD_START_ROUTINE）（W_WriterThread）,\
&thread_info[i],0,&thread_ID）;
}
//等待所有线程结束
wait_for_all=WaitForMultipleObjects（n_thread,h_Thread,TRUE,-1）;
cout<<"所有的读者和写者线程完成操作."<}
//写者优先-----写者线程
voidW_WriterThread（void*p）
{
//互斥变量
HANDLEh_Mutex1;
h_Mutex1=OpenMutex（MUTEX_ALL_ACCESS,FALSE,"mutex_for_writecount"）;
DWORDwait_for_mutex;//等待互斥变量所有权
DWORDm_delay;//延迟时间
DWORDm_ThreadRunTime;//读文件持时续间
intm_Threadhao;//线程序号
m_Threadhao=（（ThreadInfo*）（p））->Threadhao;
m_delay=（DWORD）（（（ThreadInfo*）（p））->ThreadStartTime*100）;//每秒时钟中断100次
m_ThreadRunTime=（DWORD）（（（ThreadInfo*）（p））->ThreadRunTime*100）;
Sleep（m_delay）;
cout<<"写者线程"<wait_for_mutex=WaitForSingleObject（h_Mutex1,-1）;
writecount++;
if（writecount==1）
EnterCriticalSection（&cs_Read）;
ReleaseMutex（h_Mutex1）;
EnterCriticalSection（&cs_Write）;
cout<<"写者线程"<Sleep（m_ThreadRunTime）;
cout<<"写者线程"<LeaveCriticalSection（&cs_Write）;
wait_for_mutex=WaitForSingleObject（h_Mutex1,-1）;
writecount--;
if（writecount==0）
LeaveCriticalSection（&cs_Read）;
ReleaseMutex（h_Mutex1）;
}
//写者优先-----读者线程
voidW_ReaderThread（void*p）
{
HANDLEh_Mutex2,h_Mutex3;
h_Mutex2=OpenMutex（MUTEX_ALL_ACCESS,FALSE,"mutex_for_readcount"）;
h_Mutex3=OpenMutex（MUTEX_ALL_ACCESS,FALSE,"mutex_for_read"）;
DWORDwait_for_mutex,wait_for_mutex1;
//等待互斥变量所有权
DWORDm_delay;//延迟时间
DWORDm_ThreadRunTime;//读文件持续时间
intm_Threadhao;//线程序号
m_Threadhao=（（ThreadInfo*）（p））->Threadhao;
m_delay=（DWORD）（（（ThreadInfo*）（p））->ThreadStartTime*100）;
m_ThreadRunTime=（DWORD）（（（ThreadInfo*）（p））->ThreadRunTime*100）;
Sleep（m_delay）;
cout<<"读者线程"<wait_for_mutex1=WaitForSingleObject（h_Mutex3,-1）;
EnterCriticalSection（&cs_Read）;
LeaveCriticalSection（&cs_Read）;
ReleaseMutex（h_Mutex3）;
wait_for_mutex=WaitForSingleObject（h_Mutex2,-1）;
readcount++;
if（readcount==1）
EnterCriticalSection（&cs_Write）;
ReleaseMutex（h_Mutex2）;
cout<<"读者线程"<Sleep（m_ThreadRunTime）;
cout<<"读者线程"<wait_for_mutex=WaitForSingleObject（h_Mute
升级会员 