《操作系统课程设计》

设计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 <conio.h>
#include <stdlib.h>
#include <fstream.h>
#include <io.h>
#include <string.h>
#include <stdio.h>
#define READER 'R' //读者
#define WRITER 'W' //写者
#define INTE_PER_SEC 1000 //每秒时钟中断的数目#define MAX_THREAD_NUM 64 //最大线程数
#define MAX_FILE_NUM 32 //最大文件数目数
#define MAX_STR_LEN 32 //字符串的长度
int readcount=0; //读者数目
int writecount=0; //写者数目CRITICAL_SECTION RP_Write; //临界资源
CRITICAL_SECTION cs_Write;
CRITICAL_SECTION cs_Read;
struct ThreadInfo
{
int serial; //线程序号
char entity; //线程类别(判断是读者还是写者线程)
double delay; //线程延迟时间
double persist; //线程读写操作时间
};
//////////////////////////////////////////////////////////////// ///////////
// 读者优先---读者线程
//P:读者线程信息
void RP_ReaderThread(void *p)
{
//互斥变量
HANDLE h_Mutex;
h_Mutex=OpenMutex(MUTEX_ALL_ACCESS,FALSE,"mutex_for_readcount");
DWORD wait_for_mutex; //等待互斥变量所有权
DWORD m_delay; //延迟时间
DWORD m_persist; //读文件持续时间
int m_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("Reader thread %d sents the reading require./n",m_serial);
//等待互斥信号,保证对ReadCount 的访问,修改互斥 wait_for_mutex=WaitForSingleObject(h_Mutex,-1); //读者数目增加
readcount++;
if(readcount==1)
{
//第一个读者,等待资源
EnterCriticalSection(&RP_Write);
}
ReleaseMutex(h_Mutex); //释放互斥信号
//读文件
printf("Reader thread %d begins to read file./n",m_serial); Sleep(m_persist);
//退出线程
printf("Reader thread %d finished reading
file./n",m_serial);
//等待互斥信号,保证对ReadCount的访问,修改互斥
wait_for_mutex=WaitForSingleObject(h_Mutex,-1);
//读者数目减少
readcount--;
if(readcount==0)
{
//如果所有的读者读完,唤醒写者
LeaveCriticalSection(&RP_Write);
}
ReleaseMutex(h_Mutex); //释放互斥信号
}
////////////////////////////////////////////////////////////// //P:写者线程信息
void RP_WriterThread(void *p)
{
DWORD m_delay; //延迟时间
DWORD m_persist; //写文件持续时间
int m_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("Write thread %d sents the writing
require./n",m_serial);
//等待资源
EnterCriticalSection(&RP_Write);
//写文件
printf("Writer thread %d begins to write to the
file./n",m_serial);
Sleep(m_persist);
//退出线程
printf("Write thread %d finished writing to the file./n",m_serial); //释放资源
LeaveCriticalSection(&RP_Write);
}
////////////////////////////////////////////////////////////// //读者优先处理函数
//file:文件名
void ReaderPriority(char *file)
{
DWORD n_thread=0; //线程数目
DWORD thread_ID; //线程ID
DWORD wait_for_all; //等待所有线程结束
//互斥对象
HANDLE h_Mutex;
h_Mutex=CreateMutex(NULL,FALSE,"mutex_for_readcount");
//线程对象的数组
HANDLE h_Thread[MAX_THREAD_NUM];
ThreadInfo thread_info[MAX_THREAD_NUM];
readcount=0; //初始化readcount
InitializeCriticalSection(&RP_Write); //初始化临界区
ifstream inFile;
inFile.open (file);
printf("Reader Priority:/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(int i=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_Read erThread),&thread_info[i],0,&thread_ID);
}
else
{
//创建写者线程
h_Thread[i]=CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)(RP_Writ erThread),&thread_info[i],0,&thread_ID);
}
}
//等待所有的线程结束
wait_for_all=WaitForMultipleObjects(n_thread,h_Thread,TRUE,-1); printf("All reader and writer have finished operating./n"); }
////////////////////////////////////////////////////////
//写者优先---读者线程
//P:读者线程信息
void WP_ReaderThread(void *p)
{
//互斥变量
HANDLE h_Mutex1;
h_Mutex1=OpenMutex(MUTEX_ALL_ACCESS,FALSE,"mutex1"); HANDLE h_Mutex2;
h_Mutex2=OpenMutex(MUTEX_ALL_ACCESS,FALSE,"mutex2");
DWORD wait_for_mutex1; //等待互斥变量所有权 DWORD wait_for_mutex2;
DWORD m_delay; //延迟时间
DWORD m_persist; //读文件持续时间
int m_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("Reader thread %d sents the reading
require./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("Reader thread %d begins to read file./n",m_serial); Sleep(m_persist);
//退出线程
printf("Reader thread %d finished reading file./n",m_serial); //阻塞互斥对象Mutex2,保证对readcount的访问,修改互斥
wait_for_mutex2=WaitForSingleObject(h_Mutex2,-1); readcount--;
if(readcount==0)
{
//最后一个读者,唤醒写者
LeaveCriticalSection(&cs_Write);
}
ReleaseMutex(h_Mutex2); //释放互斥信号
}
///////////////////////////////////////////
//写者优先---写者线程
//P:写者线程信息
void WP_WriterThread(void *p)
{
DWORD wait_for_mutex3; //互斥变量
DWORD m_delay; //延迟时间
DWORD m_persist; //读文件持续时间
int m_serial; //线程序号
HANDLE h_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("Writer thread %d sents the reading
require./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("Writer thread %d begins to write to the
file./n",m_serial);
Sleep(m_persist);
//退出线程
printf("Writer thread %d finished writing to the
file./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:文件名
void WriterPriority(char * file)
{
DWORD n_thread=0;//线程数目
DWORD thread_ID;//线程ID
DWORD wait_for_all;//等待所有线程结束
//互斥对象
HANDLE h_Mutex1;
h_Mutex1=CreateMutex(NULL,FALSE,"mutex1");
HANDLE h_Mutex2;
h_Mutex2=CreateMutex(NULL,FALSE,"mutex2");
HANDLE h_Mutex3;
h_Mutex3=CreateMutex(NULL,FALSE,"mutex3");
//线程对象
HANDLE h_Thread[MAX_THREAD_NUM];
ThreadInfo thread_info[MAX_THREAD_NUM];
readcount=0;//初始化readcount
writecount=0;//初始化writecount
InitializeCriticalSection(&cs_Write);//初始化临界区 InitializeCriticalSection(&cs_Read);
ifstream inFile;
inFile.open (file);//打开文件
printf("Writer priority:/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(int i=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_Read erThread),&thread_info[i],0,&thread_ID);
}
else
{
//创建写线程
h_Thread[i]=CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)(WP_Writ erThread),&thread_info[i],0,&thread_ID);
}
}
//等待所有的线程结束
wait_for_all=WaitForMultipleObjects(n_thread,h_Thread,TRUE,-1); printf("All reader and writer have finished operating./n"); }
/////////////////////////////////////////////////////
//主函数
int main(int argc,char *argv[])
{
char ch;
while(true)
{
//打印提示信息
printf("*************************************\n"); printf(" 1.Reader Priority\n");
printf(" 2.Writer Priority\n");
printf(" 3.Exit to Windows\n");
printf("*************************************\n"); printf("Enter your choice(1,2,3): ");
//如果输入信息不正确，继续输入
do{
ch=(char)_getch();
}while(ch!='1'&&ch!='2'&&ch!='3');
system("cls");
if(ch=='3')//选择3，返回
return 0;
//选择1，读者优先
else if(ch=='1')
山东科技大学学生课程设计
ReaderPriority("thread.dat");
//选择2，写者优先
else
WriterPriority("thread.dat");
//结束
printf("/nPress Any Key to Coutinue:"); _getch();
system("cls");
}
return 0;
}
31。