《操作系统课程设计》.docx
《《操作系统课程设计》.docx》由会员分享，可在线阅读，更多相关《《操作系统课程设计》.docx（21页珍藏版）》请在冰豆网上搜索。
《操作系统课程设计》
设计2读者写者问题
一、设计目的
通过对操作系统内核实现代码的阅读、修改、设计，理解和掌握复杂的操作系统的工作原理。
理解进程及信号量的概念。
二、设计要求
1、为每个读者／写者产生一个线程，设计正确的同步算法
2、每个读者/写者对该存储区进行操作后，即时显示该存储区的全部内容、当前指针位置和读者/写者线程的自定义标识符。
3、读者应有3个以上，写者应有有两个以上。
4、多个读者/写者之间须共享对存储区进行操作的函数代码。
三、设计说明
所谓读者写着问题，是指保证一个writer进程必须与其他进程互斥地访问共享对象的同步问题。
读者写者问题可以这样的描述，有一群写者和一群读者，写者在写同一本书，读者也在读这本书，多个读者可以同时读这本书，但是，只能有一个写者在写书，并且，读者必写者优先，也就是说，读者和写者同时提出请求时，读者优先。
当读者提出请求时需要有一个互斥操作，另外，需要有一个信号量S来当前是否可操作。
信号量机制是支持多道程序的并发操作系统设计中解决资源共享时进程间的同步与互斥的重要机制，而读者写者则是这一机制的一个经典范例。
主要设计流程图
读者优先
写者优先流程图
四、运行结果及分析
测试数据文件包括n行测试数据，分别描述创建的n个线程是读者还是写者，以及读写操作的开始时间和持续时间。
每行测试数据包括四个字段，各字段间用空格分隔。
第一字段为一个正整数，表示线程序号。
第二字段表示相应线程角色，R表示读者是，W表示写者。
第三字段为一个正数，表示读写操作的开始时间。
线程创建后，延时相应时间（单位为秒）后发出对共享资源的读写申请。
第四字段为一个正数，表示读写操作的持续时间。
当线程读写申请成功后，开始对共享资源的读写操作，该操作持续相应时间后结束，并释放共享资源。
下面是一个测试数据文件的例子：
1,W，4,5,
2,W,16,4,
3,R,5,2,
4,W,6,5,
5,R,4,3,
在读者写者同时在队列中等待申请资时，读者优先调用资源。
而且如果一个读者申请进行读操作时已有另一读者正在进行读操作，则该读者可直接开始读操作，即读读允许。
进程1是W操作，在时间4时进入队列,运行时间是5,在它进入时没有进程占用资源，它既占用资源；直到它释放资源，等候的进程有3，4，5；
结束界面
五、总结
这一次课程设计，我完成了题目“读者-写者问题的实现”，更加系统地理解和掌握C语言的基本概念、语言特点和编程技巧，在应用C语言在程序设计方面得到系统锻炼，为将来用C进行软件开发打下良好基础。
对程序设计思想也有了比较清晰的印象，为今后的程序设计奠定了一定的心理和技术上的准备。
总的感觉，学到了很多知识，特别对于linux有了全面的接触和了解，也开始对linux产生了兴趣，它所开放的源码的确为学计算机的同志们提供了很好的平台。
读者-写者问题经典的线程同步问题的一个模型。
经过读者写者问题的编写，我对同步机构应用有了深入的了解。
懂得了运用信号量实现进程间的互斥。
实现了不让共享资源同时修改。
用信号量上的原语操作使临界段问题的解决比较简单明了了。
读者写者问题的编写，花的时间很多，也学到很多东西。
了解支持多道程序的并发操作系统设计中解决资源共享时进程间的同步与互斥的信号量机制。
几天的试验，虽然难度有点大，但只要自己花时间去学习，还是会攻克困难的。
课程设计提高了我对所学知识的综合应用能力，全面检查并掌握所学的内容，培养独立思考、刻苦钻研的精神，在分析问题、解决问题的过程中，更是获得一种成功的喜悦，进而增加学习和应用的兴趣。
同时也要督促自己在学习的过程中不断的完善自我，加强自己的动手操作能力，培养我的独立思考的那种思维方式。
总之，每一次课程设计不仅是我们学习的好机会，而且是我们锻炼实际动手能力的平台，虽然有难度的东西总会让人很抵触，比如在课设过程中有很多郁闷的时候，一个小小的错误一不小心就花去了自己一上午的时间，所以在这个过程中能够磨练人的意志与耐心，最后感谢老师的指导与监督
附：
主要源代码
#include"windows.h"
#include
#include
#include
#include
#include
#include
#defineREADER'R'//读者
#defineWRITER'W'//写者
#defineINTE_PER_SEC1000//每秒时钟中断的数目
#defineMAX_THREAD_NUM64//最大线程数
#defineMAX_FILE_NUM32//最大文件数目数
#defineMAX_STR_LEN32//字符串的长度
intreadcount=0;//读者数目
intwritecount=0;//写者数目
CRITICAL_SECTIONRP_Write;//临界资源
CRITICAL_SECTIONcs_Write;
CRITICAL_SECTIONcs_Read;
structThreadInfo
{
intserial;//线程序号
charentity;//线程类别（判断是读者还是写者线程）
doubledelay;//线程延迟时间
doublepersist;//线程读写操作时间
};
///////////////////////////////////////////////////////////////////////////
//读者优先---读者线程
//P:
读者线程信息
voidRP_ReaderThread（void*p）
{
//互斥变量
HANDLEh_Mutex;
h_Mutex=OpenMutex（MUTEX_ALL_ACCESS,FALSE,"mutex_for_readcount"）;
DWORDwait_for_mutex;//等待互斥变量所有权
DWORDm_delay;//延迟时间
DWORDm_persist;//读文件持续时间
intm_serial;//线程序号
//从参数中获得信息
m_serial=（（ThreadInfo*）（p））->serial;
m_delay=（DWORD）（（（ThreadInfo*）（p））->delay*INTE_PER_SEC）;
m_persist=（DWORD）（（（ThreadInfo*）（p））->persist*INTE_PER_SEC）;
Sleep（m_delay）;//延迟等待
printf（"Readerthread%dsentsthereadingrequire./n",m_serial）;
//等待互斥信号,保证对ReadCount的访问,修改互斥
wait_for_mutex=WaitForSingleObject（h_Mutex,-1）;
//读者数目增加
readcount++;
if（readcount==1）
{
//第一个读者,等待资源
EnterCriticalSection（&RP_Write）;
}
ReleaseMutex（h_Mutex）;//释放互斥信号
//读文件
printf（"Readerthread%dbeginstoreadfile./n",m_serial）;
Sleep（m_persist）;
//退出线程
printf（"Readerthread%dfinishedreadingfile./n",m_serial）;
//等待互斥信号,保证对ReadCount的访问,修改互斥
wait_for_mutex=WaitForSingleObject（h_Mutex,-1）;
//读者数目减少
readcount--;
if（readcount==0）
{
//如果所有的读者读完,唤醒写者
LeaveCriticalSection（&RP_Write）;
}
ReleaseMutex（h_Mutex）;//释放互斥信号
}
//////////////////////////////////////////////////////////////
//P:
写者线程信息
voidRP_WriterThread（void*p）
{
DWORDm_delay;//延迟时间
DWORDm_persist;//写文件持续时间
intm_serial;//线程序号
//从参数中获得信息
m_serial=（（ThreadInfo*）（p））->serial;
m_delay=（DWORD）（（（ThreadInfo*）（p））->delay*INTE_PER_SEC）;
m_persist=（DWORD）（（（ThreadInfo*）（p））->persist*INTE_PER_SEC）;
Sleep（m_delay）;//延迟等待
printf（"Writethread%dsentsthewritingrequire./n",m_serial）;
//等待资源
EnterCriticalSection（&RP_Write）;
//写文件
printf（"Writerthread%dbeginstowritetothefile./n",m_serial）;
Sleep（m_persist）;
//退出线程
printf（"Writethread%dfinishedwritingtothefile./n",m_serial）;
//释放资源
LeaveCriticalSection（&RP_Write）;
}
//////////////////////////////////////////////////////////////
//读者优先处理函数
//file:
文件名
voidReaderPriority（char*file）
{
DWORDn_thread=0;//线程数目
DWORDthread_ID;//线程ID
DWORDwait_for_all;//等待所有线程结束
//互斥对象
HANDLEh_Mutex;
h_Mutex=CreateMutex（NULL,FALSE,"mutex_for_readcount"）;
//线程对象的数组
HANDLEh_Thread[MAX_THREAD_NUM];
ThreadInfothread_info[MAX_THREAD_NUM];
readcount=0;//初始化readcount
InitializeCriticalSection（&RP_Write）;//初始化临界区
ifstreaminFile;
inFile.open（file）;
printf（"ReaderPriority:
/n/n"）;
while（inFile）
{
//读入每一个读者,写者的信息
inFile>>thread_info[n_thread].serial;
inFile>>thread_info[n_thread].entity;
inFile>>thread_info[n_thread].delay;
inFile>>thread_info[n_thread++].persist;
inFile.get（）;
}
for（inti=0;i<（int）（n_thread）;i++）
{
if（thread_info[i].entity==READER||thread_info[i].entity=='r'）
{
//创建读者线程
h_Thread[i]=CreateThread（NULL,0,（LPTHREAD_START_ROUTINE）（RP_ReaderThread）,&thread_info[i],0,&thread_ID）;
}
else
{
//创建写者线程
h_Thread[i]=CreateThread（NULL,0,（LPTHREAD_START_ROUTINE）（RP_WriterThread）,&thread_info[i],0,&thread_ID）;
}
}
//等待所有的线程结束
wait_for_all=WaitForMultipleObjects（n_thread,h_Thread,TRUE,-1）;
printf（"Allreaderandwriterhavefinishedoperating./n"）;
}
////////////////////////////////////////////////////////
//写者优先---读者线程
//P:
读者线程信息
voidWP_ReaderThread（void*p）
{
//互斥变量
HANDLEh_Mutex1;
h_Mutex1=OpenMutex（MUTEX_ALL_ACCESS,FALSE,"mutex1"）;
HANDLEh_Mutex2;
h_Mutex2=OpenMutex（MUTEX_ALL_ACCESS,FALSE,"mutex2"）;
DWORDwait_for_mutex1;//等待互斥变量所有权
DWORDwait_for_mutex2;
DWORDm_delay;//延迟时间
DWORDm_persist;//读文件持续时间
intm_serial;//线程的序号
//从参数中得到信息
m_serial=（（ThreadInfo*）（p））->serial;
m_delay=（DWORD）（（（ThreadInfo*）（p））->delay*INTE_PER_SEC）;
m_persist=（DWORD）（（（ThreadInfo*）（p））->persist*INTE_PER_SEC）;
Sleep（m_delay）;//延迟等待
printf（"Readerthread%dsentsthereadingrequire./n",m_serial）;
wait_for_mutex1=WaitForSingleObject（h_Mutex1,-1）;
//读者进去临界区
EnterCriticalSection（&cs_Read）;
//阻塞互斥对象Mutex2,保证对readCount的访问和修改互斥
wait_for_mutex2=WaitForSingleObject（h_Mutex2,-1）;
//修改读者的数目
readcount++;
if（readcount==1）
{
//如果是第1个读者,等待写者写完
EnterCriticalSection（&cs_Write）;
}
ReleaseMutex（h_Mutex2）;//释放互斥信号Mutex2
//让其他读者进去临界区
LeaveCriticalSection（&cs_Read）;
ReleaseMutex（h_Mutex1）;
//读文件
printf（"Readerthread%dbeginstoreadfile./n",m_serial）;
Sleep（m_persist）;
//退出线程
printf（"Readerthread%dfinishedreadingfile./n",m_serial）;
//阻塞互斥对象Mutex2,保证对readcount的访问,修改互斥
wait_for_mutex2=WaitForSingleObject（h_Mutex2,-1）;
readcount--;
if（readcount==0）
{
//最后一个读者,唤醒写者
LeaveCriticalSection（&cs_Write）;
}
ReleaseMutex（h_Mutex2）;//释放互斥信号
}
///////////////////////////////////////////
//写者优先---写者线程
//P:
写者线程信息
voidWP_WriterThread（void*p）
{
DWORDwait_for_mutex3;//互斥变量
DWORDm_delay;//延迟时间
DWORDm_persist;//读文件持续时间
intm_serial;//线程序号
HANDLEh_Mutex3;
h_Mutex3=OpenMutex（MUTEX_ALL_ACCESS,FALSE,"mutex3"）;
//从参数中获得信息
m_serial=（（ThreadInfo*）（p））->serial;
m_delay=（DWORD）（（（ThreadInfo*）（p））->delay*INTE_PER_SEC）;
m_persist=（DWORD）（（（ThreadInfo*）（p））->persist*INTE_PER_SEC）;
Sleep（m_delay）;//延迟等待
printf（"Writerthread%dsentsthereadingrequire./n",m_serial）;
//阻塞互斥对象mutex3，保证对writecount的访问
wait_for_mutex3=WaitForSingleObject（h_Mutex3,-1）;
writecount++;//修改写者数目
if（writecount==1）
{
//第一个写者，等待读者读完
EnterCriticalSection（&cs_Read）;
}
ReleaseMutex（h_Mutex3）;
//进入写者临界区
EnterCriticalSection（&cs_Write）;
//写文件
printf（"Writerthread%dbeginstowritetothefile./n",m_serial）;
Sleep（m_persist）;
//退出线程
printf（"Writerthread%dfinishedwritingtothefile./n",m_serial）;
//离开临界区
LeaveCriticalSection（&cs_Write）;
//阻塞互斥对象mutex3,保证对writecount的访问、修改互斥
wait_for_mutex3=WaitForSingleObject（h_Mutex3,-1）;
writecount--;
if（writecount==0）
{
//写者写完，读者可以读
LeaveCriticalSection（&cs_Read）;
}
ReleaseMutex（h_Mutex3）;
}
/////////////////////////////////////////////
//写者优先处理函数
//file:
文件名
voidWriterPriority（char*file）
{
DWORDn_thread=0;//线程数目
DWORDthread_ID;//线程ID
DWORDwait_for_all;//等待所有线程结束
//互斥对象
HANDLEh_Mutex1;
h_Mutex1=CreateMutex（NULL,FALSE,"mutex1"）;
HANDLEh_Mutex2;
h_Mutex2=CreateMutex（NULL,FALSE,"mutex2"）;
HANDLEh_Mutex3;
h_Mutex3=CreateMutex（NULL,FALSE,"mutex3"）;
//线程对象
HANDLEh_Thread[MAX_THREAD_NUM];
ThreadInfothread_info[MAX_THREAD_NUM];
readcount=0;//初始化readcount
writecount=0;//初始化writecount
InitializeCriticalSection（&cs_Write）;//初始化临界区
InitializeCriticalSection（&cs_Read）;
ifstreaminFile;
inFile.open（file）;//打开文件
printf（"Writerpriority:
/n/n"）;
while（inFile）
{
//读入每一个读者、写者信息
inFile>>thread_info[n_thread].serial;
inFile>>thread_info[n_thread].entity;
inFile>>thread_info[n_thread].delay;
inFile>>thread_info[n_thread++].persist;
inFile.get（）;
}
for（inti=0;i<（int）（n_thread）;i++）
{
if（thread_info[i].entity==READER||thread_info[i].entity=='r'）
{
//创建读者进程
h_Thread[i]=CreateThread（NULL,0,（LPTHREAD_START_ROUTINE）（WP_ReaderThread）,&thread_info[i],0,&thread_ID）;
}
else
{
//创建写线程
h_Thread[i]=CreateThread（NULL,0,（LPTHREAD_START_ROUTINE）（WP_WriterThread）,&thread_info[i],0,&thread_ID）;
}
}
//等待所有的线程结束
wait_for_all=WaitForMultipleObjects（n_thread,h_Thread,TRUE,-1）;
printf（"Allreaderandwriterhavefinishedoperating./n"）;
}
///////////////////
升级会员 