//#include "stdafx.h"
#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 100  //每秒時鐘中斷數(shù)目
#define MAX_THREAD_NUM 64 //最大線程數(shù)目
#define MAX_FILE_NUM 32   //最大數(shù)據(jù)文件數(shù)目
#define MAX_STR_LEN 32    //字符串長度

//全局變量
int readcount=0;          //讀者數(shù)目
int writecount=0;         //寫者數(shù)目

CRITICAL_SECTION RP_Write; //臨界區(qū)
CRITICAL_SECTION cs_Write;
CRITICAL_SECTION cs_Read;

struct ThreadInfo
{	int serial;           //線程序號
	char entity;          //線程類別
	double delay;         //線程開始時間
	double persist;       //線程讀寫持續(xù)時間
};

//讀者優(yōu)先處理函數(shù)，已經(jīng)給出
void ReaderPriority(char* file);   
void RP_ReaderThread(void *p);
void RP_WriterThread(void *p);

//寫者優(yōu)先處理函數(shù)，精讀"讀者優(yōu)先"程序和設計分析，自己完成
void WriterPriority(char* file);  
void WP_ReaderThread(void *p);
void WP_WriterThread(void *p);

//為了保證現(xiàn)在程序編譯通過，寫一個空函數(shù)，請你寫出自己的WriterPriority
//void WriterPriority(char* file){}


int main()
{
	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 or 3)\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.txt");
			 else
			    WriterPriority("thread.txt");
		printf("\nPress Any key to continue.\n");
		_getch();
		system("cls");
	}
	return 0;
}


//讀者優(yōu)先處理函數(shù)
void ReaderPriority(char* file)
{
	DWORD n_thread=0;        //線程數(shù)目
	DWORD thread_ID;         //線程ID
	DWORD wait_for_all;      //等待所有線程結(jié)束
	//互斥對象
	HANDLE h_Mutex;
	h_Mutex=CreateMutex(NULL,FALSE,"mutex_for_readcount");
	//線程對象數(shù)組
	HANDLE h_Thread[MAX_THREAD_NUM];
	ThreadInfo thread_info[MAX_THREAD_NUM];
	readcount=0;     //初始化readcount
	InitializeCriticalSection(&RP_Write);  //初始化臨界區(qū)
	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;
		if (-1 == inFile.get())
			break;
		n_thread++;
	}
	for (int i=0;i<(int)(n_thread);i++)
	{
		if (thread_info[i].entity==READER || thread_info[i].entity=='r')
			//創(chuàng)建讀者線程
			h_Thread[i]=CreateThread(NULL,0,\
			(LPTHREAD_START_ROUTINE)(RP_ReaderThread),\
			&thread_info[i],0,&thread_ID);
		else
			//創(chuàng)建寫者線程
			h_Thread[i]=CreateThread(NULL,0,\
			(LPTHREAD_START_ROUTINE)(RP_WriterThread),\
			&thread_info[i],0,&thread_ID);
	}
	//等待所有線程結(jié)束
	wait_for_all=WaitForMultipleObjects(n_thread,h_Thread,TRUE,-1);
	printf("All Reader and Writer have finished operating.\n");
}

//讀者優(yōu)先-----讀者線程
void RP_ReaderThread(void *p)
{
	//互斥變量
	HANDLE h_Mutex;
	h_Mutex=OpenMutex(MUTEX_ALL_ACCESS,FALSE,"mutex_for_readcount");
	DWORD wait_for_mutex;   //等待互斥變量所有權(quán)
	DWORD m_delay;          //延遲時間
	DWORD m_persist;        //讀文件持續(xù)時間
	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的訪問、
													  //修改互斥
	readcount++;                                      //讀者數(shù)目增加
	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的訪問、修改互斥
	readcount--;                                     //讀者數(shù)目減少
	if (readcount==0)
		LeaveCriticalSection(&RP_Write);	         //如果所有讀者讀完，喚醒寫者
	ReleaseMutex(h_Mutex);
}

//讀者優(yōu)先-----寫者線程
void RP_WriterThread(void *p)
{
	DWORD m_delay;          //延遲時間
	DWORD m_persist;        //讀文件持續(xù)時間
	int m_serial;           //線程序號
	//從參數(shù)中獲得信息
	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 file.\n",m_serial);
	Sleep(m_persist);
	//退出線程
	printf("Writer thread %d finished writing file.\n",m_serial);
	LeaveCriticalSection(&RP_Write);	         //如果所有讀者讀完，喚醒寫者
}

//寫者優(yōu)先處理函數(shù)
void WriterPriority(char* file)
{
	DWORD n_thread=0;        //線程數(shù)目
	DWORD thread_ID;         //線程ID
	DWORD wait_for_all;      //等待所有線程結(jié)束
	//互斥對象
	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");
	//線程對象數(shù)組
	HANDLE h_Thread[MAX_THREAD_NUM];
	ThreadInfo thread_info[MAX_THREAD_NUM];
	readcount=0;     //初始化readcount
	InitializeCriticalSection(&cs_Write);  //初始化臨界區(qū)
	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;
		
		if(-1 == inFile.get())
			break;
		n_thread++;
	}
	for (int i=0;i<(int)(n_thread);i++)
	{
		if (thread_info[i].entity==READER || thread_info[i].entity=='r')
			//創(chuàng)建讀者線程
			h_Thread[i]=CreateThread(NULL,0,\
			(LPTHREAD_START_ROUTINE)(WP_ReaderThread),\
			&thread_info[i],0,&thread_ID);
		else
			//創(chuàng)建寫者線程
			h_Thread[i]=CreateThread(NULL,0,\
			(LPTHREAD_START_ROUTINE)(WP_WriterThread),\
			&thread_info[i],0,&thread_ID);
	}
	//等待所有線程結(jié)束
	wait_for_all=WaitForMultipleObjects(n_thread,h_Thread,TRUE,-1);
	printf("All Reader and Writer have finished operating.\n");
}

//寫者優(yōu)先-----寫者線程
void WP_WriterThread(void *p)
{
	//互斥變量
	HANDLE h_Mutex1;
	h_Mutex1 = OpenMutex(MUTEX_ALL_ACCESS,FALSE,"mutex_for_writecount");

	DWORD wait_for_mutex;   //等待互斥變量所有權(quán)
	DWORD m_delay;          //延遲時間
	DWORD m_persist;        //讀文件持時續(xù)間
	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);

	wait_for_mutex=WaitForSingleObject(h_Mutex1,-1);  
	writecount++;
	if (writecount==1)
		EnterCriticalSection(&cs_Read);
	ReleaseMutex(h_Mutex1);

	EnterCriticalSection(&cs_Write);
	printf("Writer thread %d begins to write file.\n",m_serial);
	Sleep(m_persist);
	printf("Writer thread %d finished writing file.\n",m_serial);
	LeaveCriticalSection(&cs_Write);

	wait_for_mutex=WaitForSingleObject(h_Mutex1,-1);  
	writecount--;
	if(writecount == 0)
		LeaveCriticalSection(&cs_Read);
	ReleaseMutex(h_Mutex1);
}

//寫者優(yōu)先-----讀者線程
void WP_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;   //等待互斥變量所有權(quán)
	DWORD m_delay;          //延遲時間
	DWORD m_persist;        //讀文件持續(xù)時間
	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_Mutex3,-1);
	EnterCriticalSection(&cs_Read);
	/*wait_for_mutex=WaitForSingleObject(h_Mutex2,-1); 
	readcount++;
	if (readcount == 1)
		EnterCriticalSection(&cs_Write);
	ReleaseMutex(h_Mutex2);*/
	LeaveCriticalSection(&cs_Read);
	ReleaseMutex(h_Mutex3);

	wait_for_mutex=WaitForSingleObject(h_Mutex2,-1); 
	readcount++;
	if (readcount == 1)
		EnterCriticalSection(&cs_Write);
	ReleaseMutex(h_Mutex2);

	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_Mutex2,-1);
	readcount--;
	if (readcount == 0)
		LeaveCriticalSection(&cs_Write);
	ReleaseMutex(h_Mutex2);
}