reader.cpp

下面是一个测试数据文件的例子: 2 W 4 5 3 R 5 2 4 R 6 5 5 W 5.1 3

#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);
  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);
  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("Writer thread %d sents the writing require.\n",m_serial);
   EnterCriticalSection(&RP_Write);
   printf("Writer thread %d begins to write the  file.\n",m_serial);
   Sleep(m_persist);
   printf("Writer thread %d finishing writing to the file.\n",m_serial);
   LeaveCriticalSection(&RP_Write);
}
/////////////////////////////////////////////////////////////////
//读者优先处理函数
//file:文件名
void ReaderPriority(char *file)
{
	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;
	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 writwe 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);
  wait_for_mutex2=WaitForSingleObject(h_Mutex2,-1);
  readcount++;
  if(readcount==1)
{
  EnterCriticalSection(&cs_Write);
}
  ReleaseMutex(h_Mutex2);
  LeaveCriticalSection(&cs_Read);
//  ReleaseMutex(h_Mutex1);
  printf("Reader thread %d begin to read the file.\n",m_serial);
  Sleep(m_persist);
  printf("Reader thread %d finished reading file.\n",m_serial);
  wait_for_mutex2=WaitForSingleObject(h_Mutex2,-1);
  readcount--;
  if(readcount==0)
{
  LeaveCriticalSection(&cs_Write);
}
  ReleaseMutex(h_Mutex2);
}
///////////////////////////////////////////////////////////////////
//写者优先-写者线程
//p:写者线程信息
void WP_WriterThread(void*p)
{
  DWORD m_delay;
  DWORD m_persist;
  int   m_serial;
  DWORD wait_for_mutex3;
  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 writing 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 begin to write the file.\n",m_serial);
  Sleep(m_persist);
  printf("writer thread %d finishing  writing 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,2or3):\n");
   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("\n press Any Key To Continue:");
   ch=(char)_getch();
   system("cls");
}
return 0;
}