当前位置：搜档网 › 操作系统课程设计--读者-写者问题

操作系统课程设计--读者-写者问题

操作系统课程设计报告

一、操作系统课程设计任务书

读者- 写者问题实现

1设计目的通过实现经典的读者写者问题，巩固对线程及其同步机制的学习效果，加深对相关基本概念的理解，并学习如何将基本原理和实际设计有机的结合。

2设计要求

在Windows 2000/XP 环境下，使用多线程和信号量机制实现经典的读者写者问题，每个线程代表一个读者或一个写者。每个线程按相应测试数据文件的要求，进行读写操作。请用信号量机制分别实现读者优先和写者优先的读者- 写者问题。

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

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

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

(3)读-读允许，即可以有二个以上的读者同时读读者优先的附加限制：如果一个读者申请进行读操作时已有另一读者正在进行读操作，则该读者可直接开始读操作。

写者优先的附加限制：如果一个读者申请进行读操作时已有另一写者在等待访问共享资源，则该读者必须等到没有写者处于等待状态后才能开始读操作。

运行结果显示要求：要求在每个线程创建、发出读写操作申请、开始读写操作和结束读写操作时分别显示一行提示信息，以确信所有处理都遵守相应的读写操作限制。

3测试数据文件格式

测试数据文件包括n 行测试数据，分别描述创建的n 个线程是读者还是写者，以及读写操作的开始时间和持续时间。每行测试数据包括四个字段，各字段间用空格分隔。第一字段为一个正整数，表示线程序号。第二字段表示相应线程角色，R 表示读者是，W 表示写者。第三字段为一个正数，表示读写操作的开始时间。线程创建后，延时相应时间(单位为秒)后发出对共享资源的读写申请。第四字段为一个正数，表示读写操作的持续时

间。

当线程读写申请成功后，开始对共享资源的读写操作，该操作持续相应时间后结束，并释放共享资源。下面是一个测试数据文件的例子：

1r 3 5

2w 4 5

3r 5 2

4r 6 5

5w 5.1 3

4相关API 函数

CreateThread ()在调用进程的地址空间上创建一个线程ExitThread ()用于结束当前线程

Sleep ()可在指定的时间内挂起当前线程

CreateMutex ()创建一个互斥对象，返回对象句柄

OpenMutex() 打开并返回一个已存在的互斥对象句柄，用于后续访问

ReleaseMutex()释放对互斥对象的占用，使之成为可用WaitForSingleObject () 可在指定的时间内等待指定对象为可用状态

InitializeCriticalSection() 初始化临界区对象EnterCriticalSection()等待指定临界区对象的所有权LeaveCriticalSection()释放指定临界区对象的所有权

文件系统的设计

通过对文件系统的设计，加深理解文件系统的内部功能及内部实现。文件系统的设计内容较多，可划分为：子目录管理、目录项结构、文件分配表( FAT)作用、创建文件、文件复制、文件头结构、程序加载方法、内存驻留( TSR)方法等，学生可相互配合，每人选做其中的某个部分。

(一)、子目录管理

1、目的：了解并掌握DOS 创建和撤消子目录的方法及有关子目录操作的系统功能。

2、内容：用DOS 功能调用39H 和3AH 来创建和撤消子目录，以及用3BH 来改变当前目录。

(1)创建指定子目录

(2)撤消子目录

（二）、目录项结构

1、目的：了解目录项中文件属性的含义及如何修改文件属性的方法。

2、内容：用DOS功能调用43H 来获取并修改文件属性。（三）、文件分配表（FAT）作用

1、目的：了解FAT作用，掌握通过FDT、FAT 恢复被删除文件的方法，特别第二个FAT 在恢复被删除文件中所起的作用。

2、内容：根据第二个FAT表，利用FDT 的保留域快速恢复被删除文件。

（四）、创建文件

1、目的：了解如何在DOS 下创建一个新文件以及由键盘上输入该文件内容的整个过程。

2、内容：由DOS 功能调用建立一个文本文件，由键盘输入该文件内容。

（五）、文件复制

1、目的：掌握文件复制的一般方法及DOS 文件管理功能调用的使用。

2、内容：

（1）读一个文本文件的内容，将该文件内容拷贝到另一个文件中。

（2）读源文件内容送入内存缓冲区，将缓冲区内容写入目的文件上，从而完成文件的拷贝。

（六）、文件头结构

1、目的：进一步了解EXE文件特点，掌握EXE 文件添加程序的方法。

2、内容：给任意一个EXE 文件添加一段程序。

（七）、程序加载方法1、目的：了解在当前程序中加载其他程序的一般方法;加深对EXEC 功能调用的掌握；了解FCB 的文件操作方式；了解内存管理功能调用。

2、内容：在当前程序中调用DOS的EXEC功能，加载执行其他

应用程序。

（八）、内存驻留（TSR）方法1、目的：掌握程序驻留内存的方法，了解如何用“热键”控制所需操作及对系统时钟的获取。

2、内容：在图形模式下的屏幕右上角“弹出”一个时钟窗口，显示出系统当前时钟的“时：分：秒”值；如果不想让时钟显示，则只要同时按下左SHIFT 键和右SHIFT 键，再按下ENTER 健，

则此时窗口被关闭；如果再想让时钟显示，只要再次同时按下左SHIFT 键和右SHIFT 键即可。

、设计思路

将所有的读者和所有的写者分别放进两个等待队列中，当读允许时就让读者队列释放一个或多个读者，当写允许时，释放第一个写者操作。

读者优先：

如果没有写者正在操作，则读者不需要等待，用一个整型变量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。

程序结构

主要代码进行分析：

1、临界区：

CRITICAL_SECTION RP_Write; // 临界区

CRITICAL_SECTION RP_Write_Reader;

临界区（Critical Section）是一段独占对某些共享资源访问的代码，在任意时刻只允许一个线程对共享资源进行访问。如果有多个线程试图同时访问临界区，那么在有一个线程进入后其他所有试图访问此临界区的线程将被挂起，并一直持续到进入临界区的线程离开。临界区在被释放后，其他线程可以继续抢占，并以此达到用原子方式操作共享资源的目的。

临界区在使用时以CRITICAL_SECTION 结构对象保护共享资源，并分别用EnterCriticalSection（）和LeaveCriticalSection（）函数去标识和释放一个临界区。所用

到的CRITICAL_SECTION 结构对象必须经过InitializeCriticalSection ()的初始化后才能使用，而且必须确保所有线程中的任何试图访问此共享资源的代码都处在此临界区的保护之下。否则临界区将不会起到应有的作用，共享资源依然有被破坏的可能。

2、定义线程结构:

struct ThreadInfo

{ int serial;

char entity;

double delay;

double persist;

};

此结构用来存放线程的信息, 四个成员变量依次表示线程序号、线

程类别、线程开始时间、线程读写持续时间。

3、互斥对象

创建互斥对象

CreateMutex(NULL,FALSE,"mutex_for_readcount");

参数含义如下：

NULL 表示创建带有默认安全性的内核对象

FALSE表示该互斥对象没有被任何线程所拥有

mutex_for_readcount 是为内核对象赋予名字。

释放互斥信号

ReleaseMutex(h_Mutex); 对资源具有访问权的线程不再需要访问此资源而要离开时，必须通过ReleaseMutex()函数来释放其拥有的互斥对象

4、创建读者线程

CreateThread(NULL,0,\(LPTHREAD_START_ROUTINE)(R_ReaderTh read),

\&thread_info[i],0,&thread_ID);

参数含义如下：

NULL表示创建带有默认安全性的内核对象

0表示新读者线程拥有自己的堆栈，使用缺省大小：

1MB。

(LPTHREAD_START_ROUTINE)(R_ReaderThread) 表示新读者线程执行的线程函数的地址

&thread_info[i] 表示在线程启动执行时将该参数传递给读者线程函数。

0表示读者线程创建后可以立即进行调度

&thread_ID 表示CreateThread 使用这个地址来存放系统分配

给新读者线程的I D

5、等待函数

WaitForMultipleObjects(n_thread,h_Thread,TRUE,-1); 等待函数可使线程自愿进入等待状态，直到一个特定的内核对象变为已通知状态为止

参数含义如下：n_thread 表示线程数量。

h_Thread是指向线程对象句柄的数组的指针。

ture 表示: 在所有线程对象变为已通知状态之前，该函数将不允许调用线程运行

参数-1 告诉系统，调用线程愿意永远等待下去(无限时间量)，直到该进程终止运行。

三、运行结果

程序运行结果如下：

本程序实现读者-写者问题

**************

1:读者优先

2:写者优先

请选择要进行的操作:

1 (回车)

读者优先:

读者线程 1 发出读请求.

读者线程 1 开始读文件.

写者线程 2 发出写请求. 读者线程 3 发出读请求. 读者线程

3 开始读文件. 写者线程 5 发出写请求. 读者线程

4 发出读

请求. 读者线程 4 开始读文件. 读者线程 3 完成读文件. 读者线程 1 完成读文件. 读者线程 4 完成读文件. 写者线程 2 开始写文件. 写者线程 2 完成写文件. 写者线程 5 开始写文件. 写者线程 5 完成写文件. 所有的读者和写者线程完成操作是否还有继续? 1. 继续 2.退出

1 （回车）

本程序实现读者-写者问题

**************

1:读者优先

2:写者优先

请选择要进行的操作:

2 （回车）

写者优先:

读者线程 1 发出读请求. 读者线程 1 开始读文件. 写者线程 2 发出写请求. 读者线程 3 发出读请求. 写者线程 5 发出写请求. 读者线程 4 发出读请求. 读者线程 1 完成读文件. 写者线程 2 开始写文件. 写者线程 2 完成写文件. 写者线程 5 开始写文件. 写者线程 5 完成写文件. 读者线程 3 开始读文件. 读者线程 4 开始读文件.

读者线程 3 完成读文件. 读者线程 4 完成读文件. 所有的读

者和写者线程完成操作是否还有继续? 1. 继续 2.退出

四、设计总结

本次操作系统课程设计完成的是读者- 写者问题，通过学习对线程及其同步机制有了很的学习和掌握. 并认识到同步可以

保证在一个时间内只有一个线程对某个资源有控制权。共享资源包括全局变量、公共数据成员或者句柄等。同步还可以使得有关

联交互作用的代码按一定的顺序执行。同时也掌握了实现线程同步的对象有Critical_section （关键段），Event（事件），Mutex（互斥对象），Semaphores（信号量）并对这些对象理解如下：

对于关键段对象：首先，定义一个关键段对象; 然后，初始化该对象。初始化时把对象设置为NOT_SINGALE，D表示允许线程使用资源：如果一段程序代码需要对某个资源进行同步保护，则这是一段关键段代码。在进入该关键段代码前调用EnterCriticalSection 函数，这样，其他线程都不能执行该段代码，若它们试图执行就会被阻塞。完成关键段的执行之后，调用LeaveCriticalSection 函数，其他的线程就可以继续执行该段代码。如果该函数不被调用，则其他线程将无限期的等待。

对于互斥对象首先，调用CreateMutex 创建互斥对象；然后，调用等待函数，可以的话利用关键资源；最后，调用RealseMutex 释放互斥对象。互斥对象可以在进程间使用，但关键段对象只能用于同一进程的线程之间。

对于等待函数：等待函数有： 1. 等待单个对象的（FOR SINGLE OBJECT）: WaitForSingleObject, 函数参数包括同步对象的句柄和等待时间等。如果等待时间不限制（Infinite），则只有同步对象获得信号才返回；如果等待时间为0，则在测试了同步对象的

状态之后马上返回。 2.等待多个对象的(FOR MULTIPLE OBJECTS) WaitForMultipleObjects, 函数参数包括同步对象的句柄，等待时间，是等待一个还是多个同步对象等等, 如果等待时间不限制(Infinite) ，则只有同步对象获得信号才返回；如果等待时间为0，则在测试了同步对象的状态之后马上返回。

操作系统设计使我对C++有了一个很好的复习和学习，对线程的创建及同步问题及其同步对象都有了很好的理解。并能初步进行简单的程序编程。并对程序的调式过程，也使我更好了解到线程同步的具体运行过程，使我更好的理解程序。

学习语言是一个漫长的过程，我想只有在不断的实践练习中，才能更好的掌握编程的技巧，提高自己的编程能力，通过此次课设也让我深深体会到自己还有很多东西需要学习，还有很多课程需要复习。总之，此次课程设计使我收益匪浅。

五、源代码

#include

#include "fstream.h"

int readcount=0; // 读者数目

int writecount=0; // 写者数目

CRITICAL_SECTION RP_Write; // 临界区

CRITICAL_SECTION cs_Write;

CRITICAL_SECTION cs_Read;

struct ThreadInfo

{ int Threadhao; char

ThreadClass; double

ThreadStartTime;

double ThreadRunTime; };

void ReaderFun( char* file); void

R_ReaderThread( void void R_WriterThread( void

// 线程信息

// 线程序号

// 线程类别

// 线程开始时间

// 线程读写持续时

间

// 读者优先函数

p); // 处理读者优先读者线程p); // 处理读者优先

void WriterFun( char* file); void W_ReaderThread(void *p); void W_WriterThread( void *p); int main()// 主函数 {

char select;

cout<<"\n

*****"<

cout<<" 请选择要进行的操作 :"<

{

cin>>select;

if (select!='1' && select!='2' && select!='3')

cout<<" 你操作有误，请重试！ "<

} while (select!='1' && select!='2' && select!='3'); system("cls");

if (select=='3')

return 0; // 退出

else if (select=='1') // 调用读者优先

ReaderFun("peizhi.txt");

else if (select=='2') // 调用写者优先

WriterFun("peizhi.txt");

cout<<"\n 是否还有继续 ? 1. 继续 2. 退出 "<

{

cin>>select;

if (select!='1' && select!='2' )

cout<<" 你操作有误，请重试！ "<

} while (select!='1' && select!='2');

if (select=='2')

while

( true )

{

本程序实现读者 - 写者问题 *******\n"<

dl; cout<<" cout<<" cout<<" 1:

3: 读者优先 "<

return 0; // 退出 system("cls");

}

return 0;

}

// 读者优先函数 void ReaderFun( char* file) {

DWORD n_thread=0; DWORD thread_ID; DWORD wait_for_all; // 临界资源 HANDLE

h_Mutex;

// 互斥对象 (h_Mutex) 确保线程拥有对单个资源的互斥访问权

h_Mutex=CreateMutex(NULL,FALSE,"mutex_for_readcount" ); HANDLE h_Thread[64]; // 线程对象数组，最大 64

ThreadInfo thread_info[64];

readcount=0;

InitializeCriticalSection(&RP_Write); // 初始化临界区 ifstream inFile;

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 ( int i=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

// 线程数初值为

// 线程 ID

{

// 创建写者线程

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

(LPTHREAD_START_ROUTINE)(R_WriterThread),\

&thread_info[i],0,&thread_ID);

} wait_for_all=WaitForMultipleObjects(n_thread,h_Threa

d,TRUE,-1);

cout<<" 所有的读者和写者线程完成操作."<

}

// 读者优先读者线程

void R_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_ThreadRunTime; // 读文件持续时间

int m_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); // 释放互斥信号

}

// 读者优先写者线程

void R_WriterThread( void *p)

{

DWORD m_delay; // 延迟时间

DWORD m_ThreadRunTime;/ / 读文件持续时间

int m_Threadhao; // 线程序号

// 从参数中获得信息

m_Threadhao=((ThreadInfo *)(p))->Threadhao;

m_delay=(DWORD)(((ThreadInfo *)(p))->ThreadStartTime*100);

m_ThreadRunTime=(DWORD)(((ThreadInfo

*)(p))->ThreadRunTime*100);

Sleep(m_delay); // 延迟等待

cout<<" 写者线程 "<

// 退出线程

cout<<" 写者线程 "<

}

// 写者优先处理函数

void WriterFun( char* file) {

DWORD n_thread=0; DWORD thread_ID; DWORD wait_for_all; // 互斥对象

HANDLE h_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"); // 线程对象数组

HANDLE h_Thread[64];

ThreadInfo thread_info[64];

readcount=0; // 初始化 readcount

InitializeCriticalSection(&cs_Write); // 初始化临界 InitializeCriticalSection(&cs_Read);

ifstream inFile;

inFile.open(file); // 打开文件

cout<<" 写者优先 :\n"<

while (inFile)

{// 读入每一个读者、写者的信息

inFile>>thread_info[n_thread].Threadhao

// 线程数目

// 线程 ID

// 等待所有线程结

>>thread_info[n_thread].ThreadClass

>>thread_info[n_thread].ThreadStartTime

>>thread_info[n_thread].ThreadRunTime;

if (-1 == inFile.get())

break ;

n_thread++; // 线程数加一

}

for ( int i=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_Threa d,TRUE,-1);

cout<<" 所有的读者和写者线程完成操作."<

}

// 写者优先写者线程

void W_WriterThread( void *p)

{

// 互斥变量

HANDLE h_Mutex1;

h_Mutex1 =

OpenMutex(MUTEX_ALL_ACCESS,FALSE,"mutex_for_writecount") DWORD wait_for_mutex; // 等待互斥变量所有权

DWORD m_delay; // 延迟时间

DWORD m_ThreadRunTime; // 读文件持时续间

int m_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);

}

// 写者优先读者线程

void W_ReaderThread(void *p)

{

HANDLE h_Mutex2, h_Mutex3;

h_Mutex2 =

OpenMutex(MUTEX_ALL_ACCESS,FALSE,"mutex_for_readcount");

h_Mutex3 =

OpenMutex(MUTEX_ALL_ACCESS,FALSE,"mutex_for_read");

DWORD wait_for_mutex, wait_for_mutex1;

// 等待互斥变量所有权

DWORD m_delay; // 延迟时间

DWORD m_ThreadRunTime; // 读文件持续时间int

m_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_Mutex2,-1);

readcount--;

if (readcount == 0)

LeaveCriticalSection(&cs_Write);

ReleaseMutex(h_Mutex2);

}

操作系统课程设计--读者-写者问题

相关文档

最新文档