北理工操作系统读者-写者问题实验报告讲解

实验二：读者写者问题

班级： 学号： 姓名：

实验二：读者写者问题

一、实验目的

1. 通过编写和调试程序以加深对进程、线程管理方案的理解； 2. 熟悉Windows多线程程序设计方法；

二、实验要求

在Windows环境下，创建一个控制台进程，此进程包含n个线程。用这n个线程来表示n个读者或写者。每个线程按相应测试数据文件（后面介绍）的要求进行读写操作。用信号量机制分别实现读者优先和写者优先问题。

读者-写者问题的读写操作（包括读者优先和写者优先） 1） 写-写互斥：不能有两个写者同时进行写操作

2） 读-写互斥：不能同时有一个线程在读，而另一个线程在写。 3） 读-读允许：可以有一个或多个读者在读。 读者优先的附加：如果读者申请进行读操作时已有另一个读者正在进行读操作，则该读者可直接开始读操作。

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

测试数据文件包括 n行测试数据，分别描述创建的n个线程是读者还是写者，以及读写操作的开始时间和持续时间。每行测试数据包括四个字段，每个字段间用空格分隔。第1个字段为正整数，表示线程的序号。第2个字段表示线程的角色，R表示读者，W表示写者。第3个字段为一个正数，表示读写开始时间：线程创建后，延迟相应时间（单位为秒）后发出对共享资源的读写申请。第4个字段为一个正数，表示读写操作的延迟时间。当线程读写申请成功后，开始对共享资源进行读写操作，该操作持续相应时间后结束，释放该资源。

下面是一个测试数据文件的例子(在记事本手工录入数据)： 1 R 3 5 2 W 4 5 3 R 5 2 4 R 6 5 5 W 5.1 3

三、实验环境

硬件设备：个人计算机。

系统软件：windows操作系统，Visual C++6.0编译环境。

四、实验原理

所谓读者写者问题，可以这样的描述，有一群写者和一群读者，写者在写同一本书，读者也在读这本书，多个读者可以同时读这本书，但是，只能有一个写者在写书，并且，读者比写者优先，也就是说，读者和写者同时提出请求时，读者优先。当读者提出请求时需要有一个互斥操作，另外，需要有一个信号量S来当前是否可操作。

信号量机制是支持多道程序的并发操作系统设计中解决资源共享时进程间的同步与互斥的重要机制，而读者写者则是这一机制的一个经典范例。

与记录型信号量解决读者—写者问题不同，信号量机制它增加了一个，即最多允许RN个读者同时读。为此，又引入了一个信号量L,并赋予初值为RN，通过执行wait（L,1,1）操作，来控制读者的数目，每当有一个读者进入时，就要执行wait（L,1,1）操作，使L的值减1。当有RN个读者进入读后，L便减为0，第RN+1 个读者要进入读时，必然会因wait（L,1,1）操作失败而堵塞。对利用信号量来解决读者—写者问题的描述如下： Var RN integer;L,mx:semaphore: =RN,1； Begin Parbegin

Reader :begin Repeat

Swait（L,1,1）; Swait（mx,1,0）;

Perform reader operation; Ssignal(L,1); Until false; End

Writer ：begin Repeat

Swait(mx ,1,1,l,RN,0); Perform writer operation; Ssignal(mx,1); Until false; End Parend End

其中，Swait（mx,1,0）语句起着开关作用，只要无Writer进程进入些，mx=1，reader进程就都可以进入读。但是要一旦有Writer进程进入写时，其MX=0，则任何reader进程就都无法进入读。Swait(mx ,1,1,l,RN,0)语句表示仅当既无Write进程在写（mx=1），又无reader进程在读（L=RN）时，writer进程才能进入临界区写。 将所有的读者和所有的写者分别放进两个等待队列中，当读允许时就让读者队列释放一个或多个读者，当写允许时，释放第一个写者操作。读者写者问题的定义如下：有一个许多进程共享的数据区，这个数据区可以是一个文件或者主存的一块空间；有一些只读取这个数据区的进程（Reader）和一些只往数据区写数据的进程(Writer)，此外还需要满足以下条件： 1)任意多个读进程可以同时读这个文件； 2) 一次只有一个写进程可以往文件中写；

3）如果一个写进程正在进行操作，禁止任何读进程度文件。 程序由三部分组成：

1.读者模块：包括系统调用接口，读者活动描述主程序。系统接口主要功能是通过管道向父进程发送系统调用命令，并读取父进程送来的返回值。

2.写者模块：包括系统调用接口，写者活动描述主程序。读者-写者活动程序根据临界资源的共享，互斥原则编制。

3.主控模块：主控模块实现系统初始化系统调用命令接收与解释执行，系统调用功能的实现

（包括信号量机制），及读者-写者活动过程记录与显示。

五、实验结果

使用的测试文件如下：

1 R 3 5 2 W 4 5 3 R 5 2 4 R 6 5 5 W 5.1 3

读者优先：按时间顺序，进程1发送读请求，并进入读文件。2发送写请求，读写互斥，不能进行写操作。3发送读请求，并开始读。5发送写请求，同进程2。4发送读请求，并开始读。按时间顺序，进程1,3,4先后完成读操作，2开始写操作，写操作不能同时进行，2完成写操作后，5才能开始写操作。

写着优先：按时间顺序，进程1发送读请求，并进入读文件。2发送写请求，读写互斥，不能进行写操作，3发送读请求，5发送写请求，4发送读请求。1完成读请求后，由于写者优先，2进行写操作，并且其他操作不能进行。2完成写操作后，5进行写操作。完成后按顺序先后同时进行3，4读操作。

六、感想体会 七、实验代码

# include \"windows.h\" # include # include # include # include # include # include

# define READER 'R' # define WRITER 'W'

// 读者 // 写者

// 每秒时钟中断数目 // 最大线程数目 // 最大数据文件数目 // 字符串长度 // 读者数目

// 写者数目

# define INTE_PER_SEC 1000 # define MAX_THREAD_NUM # define MAX_FILE_NUM 32 # define MAX_STR_LEN 32

int readcount = 0;

CRITICAL_SECTION RP_Write; CRITICAL_SECTION cs_Write; CRITICAL_SECTION cs_Read; struct ThreadInfo

int writecount = 0;

// 临界区

{

serial; entity; delay;

// 线程序号

// 线程类别 (判断是读者线程还是写者线程) // 线程延迟

// 线程读写操作持续时间

int char double 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) ;

// 读文件

printf( \"Reader thread %d begins to read file.\\n\" , m_serial) ; Sleep(m_persist) ;

}

// 释放互斥信号

ReleaseMutex(h_Mutex) ;

// 延迟等待

// 等待互斥变量所有权 // 延迟时间 // 线程序号

{

// 读文件持续时间

// 退出线程

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

// 读者优先--写者线程 // 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(\"Writer 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(\"Writer thread %d finishing writing to the file.\\n\" , m_serial) ; // 释放资源

LeaveCriticalSection(&RP_Write) ; }

// 延迟等待

}

// 释放互斥信号

}

ReleaseMutex(h_Mutex) ;

// 读者优先处理函数 // file: 文件名

void ReaderPriority(char * file)

{

// 线程数目

// 等待所有线程结束

// 线程ID

DWORD n_thread = 0; DWORD thread_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; ifstream inFile; inFile.open(file) ; 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() ; {

// 创建读者线程

h_Thread[i] = CreateThread(NULL, 0,

(LPTHREAD_START_ROUTINE) (RP_ReaderThread) , &thread_info[i] , 0, &thread_ID) ;

} else { }

for (int i = 0; i < (int) (n_thread) ; i ++) {

// 打开文件

printf(\"Reader Priority: \\n \\n\" ) ;

// 初始化readcount

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

if (thread_info[i].entity == READER || thread_info[i].entity == 'r' )

// 创建写者线程

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(\"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)

// 延迟等待

// 延迟时间 // 读文件持续时间 // 线程序号

// 等待互斥变量所有权

{ } }

}

{ }

// 释放互斥信号mutex2

// 如果是第一个读者，等待写者写完

EnterCriticalSection(&cs_Write) ; ReleaseMutex(h_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) { }

// 写者优先--写者线程 // p: 写者线程信息

void WP_WriterThread(void * p)

{

// 延迟时间 // 写文件持续时间 // 线程序号

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

// 最后一个读者，唤醒写者 }

// 释放互斥信号

LeaveCriticalSection(&cs_Write) ; ReleaseMutex(h_Mutex2) ;

DWORD wait_for_mutex3;

Sleep(m_delay) ;

// 延迟等待

printf(\"Writer thread %d sents the writing 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 finishing writing to the file.\\n\" , m_serial) ; // 离开临界区

LeaveCriticalSection(&cs_Write) ;

// 阻塞互斥对象mutex3，保证对writecount的访问、修改互斥 wait_for_mutex3 = WaitForSingleObject(h_Mutex3, -1) ; writecount --; if (writecount == 0)

/// / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / /

// 写者优先处理函数 // file: 文件名

void WriterPriority(char * file) {

DWORD n_thread = 0; DWORD thread_ID;

// 线程数目 // 线程ID

}

{ }

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

LeaveCriticalSection(&cs_Read) ; ReleaseMutex(h_Mutex3) ;

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; writecount = 0;

// 初始化readcount

// 初始化writecount

InitializeCriticalSection(&cs_Write) ; // 初始化临界区 InitializeCriticalSection(&cs_Read) ; ifstream inFile; inFile.open(file) ; 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 ++) {

// 创建读者线程

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

{

if (thread_info[i].entity == READER || thread_info[i].entity == 'r' )

// 打开文件

printf(\"Writer Priority: \\n \\n\" ) ;

}

}

// 等待所有钱程结束

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( \" printf( \"

2: Writer Priority\\n\" ) ; 3: Exit to Windows\\n\" ) ;

}

printf(\"**********************************************\\n\" ) ; printf( \"Enter your choice (1, 2 or 3) : \" ) ; // 如果输入信息不正确，继续输入 do {

ch = (char) _getch() ;

} while (ch != '1' && ch != '2' && ch != '3') ;

system( \"cls\" ) ; // 选择3，返回 if (ch == '3' ) return 0;

// 选择1, 读者优先 else if (ch == 1)

ReaderPriority( \"thread.dat\" ) ; // 选择2，写者优先 else

WriterPriority( \"thread.dat\" ) ; // 结束

printf( \"\\nPress Any Key To Continue: \" ) ; _getch() ; system( \"cls\" ) ; }

return 0; }