readerandwriter.cpp

计算机专业操作系统读者和写者问题源码

#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_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("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);

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

 

       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;

       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;

       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_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("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')

                     return 0;

              else if(ch=='1')

                     ReaderPriority("thread.dat");

              else

                     WriterPriority("thread.dat");

              printf("\nPress Any Key to Coutinue:");

              _getch();

              system("cls");

}

       return 0;

}