《操作系统课程设计》

千里之行，始于足下让知识带有温度。第第2页/共2页精品文档推荐《操作系统课程设计》设计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(

}

ReleaseMutex(h_Mutex);//释放互斥信号

//读文件

printf("Readerthread%dbeginstoreadfile./n",m_serial);Sleep(m_persist);

//退出线程

printf("Readerthread%dfinishedreading

file./n",m_serial);

//等待互斥信号,保证对ReadCount的拜访,修改互斥

wait_for_mutex=WaitForSingleObject(h_Mutex,-1);

//读者数目削减

readcount--;

if(readcount==0)

{

//假如全部的读者读完,唤醒写者

LeaveCriticalSection(

}

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%dsentsthewriting

require./n",m_serial);

//等待资源

EnterCriticalSection(

//写文件

printf("Writerthread%dbeginstowritetothe

file./n",m_serial);

Sleep(m_persist);

//退出线程

printf("Writethread%dfinishedwritingtothefile./n",m_serial);//释放资源

LeaveCriticalSection(

}

////////////////////////////////////////////////////////////////读者优先处理函数

//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(//初始化临界区

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;iserial;

m_delay=(DWORD)(((ThreadInfo*)(p))->delay*INTE_PER_SEC);m_persist=(DWORD)(((ThreadInfo*)(p))->persist

*INTE_PER_SEC);

Sleep(m_delay);//延迟等待

printf("Readerthread%dsentsthereading

require./n",m_serial);

wait_for_mutex1=WaitForSingleObject(h_Mutex1,-1);

//读者进去临界区

EnterCriticalSection(

//堵塞互斥对象Mutex2,保证对readCount的拜访和修改互斥

wait_for_mutex2=WaitForSingleObject(h_Mutex2,-1);

//修改读者的数目

readcount++;

if(readcount==1)

{

//假如是第1个读者,等待写者写完

EnterCriticalSection(

}

ReleaseMutex(h_Mutex2);//释放互斥信号Mutex2

//让其他读者进去临界区

LeaveCriticalSection(

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(

}

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%dsentsthereading

require./n",m_serial);

//堵塞互斥对象mutex3，保证对writecount的拜访

wait_for_mutex3=WaitForSingleObject(h_Mutex3,-1);

writecount++;//修改写者数目

if(writecount==1)

{

//第一个写者，等待读者读完

EnterCriticalSection(

}

ReleaseMutex(h_Mutex3);

//进入写者临界区

EnterCriticalSection(

//写文件

printf("Writerthread%dbeginstowritetothe

file./n",m_serial);

Sleep(m_persist);

//退出线程

printf("Writerthread%dfinishedwritingtothe

file./n",m_serial);

//离开临界区

LeaveCriticalSection(

//堵塞互斥对象mutex3,保证对writecount的拜访、修改互斥

wait_for_mutex3=WaitForSingleObject(h_Mutex3,-1);writecount--;

if(writecount==0)

{

//写者写完，读者可以读

LeaveCriticalSection(

}

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(//初始化临界区InitializeCriticalSection(

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),

}

else

{

//创建写线程

h_Thread[i]=CreateThread(NULL,0,(LPTHREAD_START_ROUTINE