write_first.cpp

写者优先问题。操作限制：1）写-写互斥；2）读-写互斥；3）读-读允许；写者优先的附加限制：如果一个读者申请进行读操作时已有另一写者在等待访问共享资源

//
//
//********        作者：  happy_zh  ********//
//
//********************************操作系统实验一 *****************************//
//
//***************************进程同步的读者-写者问题**************************//
//
// 操作限制：
// 1）写-写互斥；
// 2）读-写互斥；
// 3）读-读允许；
// 读者优先的附加限制：如果一个读者申请进行读操作时已有另一读者正在进行读操作，
//  则该读者可直接开始读操作。 
// 写者优先的附加限制：如果一个读者申请进行读操作时已有另一写者在等待访问共享资
//  源，则该读者必须等到没有写者处于等待状态后才能开始读操作。

#include <windows.h>
#include <fstream.h>
#include <stdio.h>
#include <string.h>
#include <conio.h>
#include <iostream.h>

#define INTE_PER_SEC	1000
#define MAX_THREAD_NUM	64       //最多线程是64个。

struct ThreadInfo
{
    int serial;         //线程序号。
	char entity;        //char型的实体线程。
	double delay;       //double型的延迟时间。
	double runtime;     //现成执行时要求的时间。
};

//全局变量的定义

//临界区对象的声明，用于管理互斥访问．
HANDLE h_Thread[MAX_THREAD_NUM];			//用于存储每个线程句柄的数组
ThreadInfo	Thread_Info[MAX_THREAD_NUM];	//线程信息数组
HANDLE h_mutex,r_mutex,w_mutex,mutex;				//互斥量
DWORD n_Thread=0;							//实际的线程数目
HANDLE h_Semaphore;							//一个信号量
int  readcount=0;							//记录正在读的人数
int  writecount=0;

//读者函数和写者函数的声明
void Writer(void *p);
void Reader(void *p);


//main函数开始：
int main(int argc,char **argv)
{  

    cout<<"This is writer first ! \n";
	DWORD wait_for_all;                     //用于控制程序结束。

    ifstream inFile;                        //准备开始读文件。
    if (argc!=2)	{
		printf("Usage:%s <test.txt>\n",argv[0]);
		return 1;
	}
   inFile.open(argv[1]); 

   //从文件中读取所有的信息，分别放在Thread_Info[n_Thread]里。
   while (inFile && !inFile.eof()) {     
        inFile >> Thread_Info[n_Thread].serial;          
		inFile >> Thread_Info[n_Thread].entity;
		inFile >> Thread_Info[n_Thread].delay;
		inFile >> Thread_Info[n_Thread].runtime;
        n_Thread++;
	}

    //读文件结束，下面显示所读到的内容：
   printf("\n The information is : \n");
	for (int j=0;j<(int)n_Thread;j++) {
		int Temp_serial=Thread_Info[j].serial;
		char Temp_entity=Thread_Info[j].entity;
		double Temp_delay=Thread_Info[j].delay;
		double Temp_runtime=Thread_Info[j].runtime;
		printf(" \n  thread %2d %c %f %f ",Temp_serial,Temp_entity,Temp_delay,Temp_runtime);
	}
	printf("\n\n");
    printf(" Now the work begins : \n\n");

    //创建在模拟过程中必要的信号量
	h_mutex=CreateMutex(NULL,false,"semaphore_for_Switch");	
	r_mutex=CreateMutex(NULL,false,"mutex_for_Rmutex");
	w_mutex=CreateMutex(NULL,false,"mutex_for_Wmutex");

	mutex=CreateMutex(NULL,false,"mutex_for_mutex");


	//创建读者者和写者线程
	for (int i=0;i<(int)n_Thread;i++) {
		if (Thread_Info[i].entity=='R')
			h_Thread[i]=CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)(Reader),&(Thread_Info[i]),0,NULL);
		else
			h_Thread[i]=CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)(Writer),&(Thread_Info[i]),0,NULL);
	}

    //主程序等待各个线程的动作结束
	wait_for_all=WaitForMultipleObjects(n_Thread,h_Thread,TRUE,-1);

    //显示结束信息
	printf(" \n All reader and writer have finished their work.\n\n");
	printf(" Press any key to quit!\n");
	_getch();

	return 0;
}
//main函数结束


//读者进程：

//  repeat.........
//
//	P( h_mutex );   用于实现写者优先  
//  p( r_mutex );
//	if(readcount==0) then p( w_mutex );
//  readcount+=1;
//	v( r_mutex );
//	v( h_mutex );     
//
//  .....read.....
//
//  p( r_mutex );
//  readcount-=1;
//  if(readcount==0) then v( w_mutex );
//  v( r_mutex );
//
//  ........until false;

//每一步的具体实现为：

void Reader(void *p)
{  
    DWORD wait_for_hmutex,wait_for_rmutex,wait_for_wmutex;   
	DWORD m_delay,m_runtime;
	int m_serial;
	
	m_serial=((ThreadInfo *)(p))->serial;
	m_delay=(DWORD)(((ThreadInfo *)(p))->delay*INTE_PER_SEC);
	m_runtime=(DWORD)(((ThreadInfo *)(p))->runtime*INTE_PER_SEC);
 
	Sleep(m_delay);
    printf("  Reader %2d requires to read .\n",m_serial);
 
	wait_for_hmutex=WaitForSingleObject(h_mutex,-1);
	wait_for_rmutex=WaitForSingleObject(r_mutex,-1);

	if(readcount==0)
	    wait_for_wmutex=WaitForSingleObject(w_mutex,-1); 
	readcount=readcount+1; 
    
	ReleaseMutex(r_mutex);
	ReleaseMutex(h_mutex);

	printf("  Reader %2d begins   reading .\n",m_serial);

    Sleep(m_runtime);     //执行了这么多时间
    printf("  Reader %2d finishes reading .\n",m_serial);

    wait_for_rmutex=WaitForSingleObject(r_mutex,-1);   
	readcount-=1;

	if(readcount==0)     ReleaseMutex(w_mutex); 
	ReleaseMutex(r_mutex);
}


//写者进程：

//  repeat.........
//  
//  p( mutex );
//	if( writecount==0 ) then P( h_mutex );   用于实现写者优先 
//  writecount+=1;
//  v( mutex ); 
//
//  p( w_mutex );
//  .....write.....
//  v( w_mutex );
//
//  p( mutex );
//  write-=1;
//  if( writecount==0 ) then v( h_mutex );   
//	v( w_mutex );
//  
//  ........until false;

//每一步的具体实现为：

void Writer(void *p)
{ 
	DWORD wait_for_hmutex,wait_for_wmutex,wait_for_mutex;
	DWORD m_delay,m_runtime;
	int m_serial;

	m_serial=((ThreadInfo *)(p))->serial;
	m_delay=(DWORD)(((ThreadInfo *)(p))->delay*INTE_PER_SEC);
    m_runtime=(DWORD)(((ThreadInfo *)(p))->runtime*INTE_PER_SEC);

	Sleep(m_delay);
    printf("  Writer %2d requests to write.\n",m_serial); 

    wait_for_wmutex=WaitForSingleObject(mutex,-1);
    if(writecount==0)
		wait_for_hmutex=WaitForSingleObject(h_mutex,-1);
	writecount++;

	ReleaseMutex(mutex);

    wait_for_mutex=WaitForSingleObject(w_mutex,-1); 

    printf("  writer %2d begins   writing .\n",m_serial);

	Sleep(m_runtime);   //执行这么多时间。
 	printf("  Writer %2d finishes writing .\n",m_serial);

    ReleaseMutex(w_mutex);

	wait_for_wmutex=WaitForSingleObject(mutex,-1);
	writecount-=1;
    
    if(writecount==0)  
    	ReleaseMutex(h_mutex);
    ReleaseMutex(mutex);
}