duzhe-xiezhe.cpp

操作系统实验

#include <windows.h>
#include <conio.h> 
#include "fstream.h" 
#include <stdio.h>


int read_count=0;          //记录读者数目，开始为0
int write_count=0;         //记录写者数目，开始为0

CRITICAL_SECTION RP_Write; //临界资源区
CRITICAL_SECTION cs_Write;
CRITICAL_SECTION cs_Read;
struct ProcessInfo               //线程信息
{	int Process_serial_number;              //线程序号
	double Process_Delay;       //线程读/写持续时间
	double Process_Start;     //线程开始时间
	char ProcessClass;           //判断线程是读者还是写者（即线程类别）
};
void R_Fun(char* file);//读者优先函数	
void R_ReaderProcess(void *p);//处理读者优先读者线程
void R_WriterProcess(void *p);//处理读者优先写者线程
void W_Fun(char* file);  //写者优先函数
void W_ReaderProcess(void *p);//处理写者优先读者线程
void W_WriterProcess(void *p);//处理写者优先写者线程
int main()   //进程主函数
{
	char select;
	while (true)
	{
		printf("★★★★★★★★★★★★验证实现读者-写者问题★★★★★★★★★★★★\n");
		printf("\n");
		printf("               a:执行读者优先\n");
		printf("\n");
		printf("               b:执行写者优先\n");
		printf("\n");
		printf("               c:关闭本窗口\n");
		printf("\n");
        printf("  根据提示选择要进行的操作:");

    	do
		{
			cin>>select;
			if(select!='a' && select!='b' && select!='c')
				printf("\n 输入错误，务必选择a/b/c中的一个字母!");

		}while (select!='a' && select!='b' && select!='c');
		system("cls");
		if (select=='c')
			return 0;//关闭本窗口
		else if (select=='a')    //运行读者优先函数
				R_Fun("yanzheng.txt");
			 else if(select=='b')    //运行写者优先函数
			    W_Fun("yanzheng.txt");
			 printf("\n  是否还要继续?   1. 继续（返回主窗口）   2.退出（关闭该程序）");

		do
		{
			cin>>select;
			if(select!='1' && select!='2' )
				printf("\n 输入错误，务必输入1/2中的一项!");

		}while (select!='1' && select!='2');
		if(select=='2')
			return 0;//	退出（关闭程序）
		system("cls");
	}
	return 0;
}

//以下为读者优先函数
void R_Fun(char* file)
{
	DWORD Process_ID;         //线程ID
	DWORD waiting_for_all_process;      //等待所有线程结束
	DWORD Processnumber=0;        //定义线程数初值为0    
	//临界资源
	HANDLE h_Mutex;        
	//互斥对象(h_Mutex)确保线程拥有对单个资源的互斥访问权
	h_Mutex=CreateMutex(NULL,FALSE,"mutex_for_read_count");
	HANDLE h_process[64];	//线程对象数组，最大64
	ProcessInfo process_info[64];
	read_count=0;     
	InitializeCriticalSection(&RP_Write);  //初始化临界区
	ifstream inFile;
	inFile.open(file); 
	printf("       读者优先  运行过程:\n");
    printf("\n");
	while (inFile)
	{//读入每一个读者/写者的信息
	inFile>>process_info[Processnumber].Process_serial_number
    >>process_info[Processnumber].ProcessClass
	>>process_info[Processnumber].Process_Start
    >>process_info[Processnumber].Process_Delay;
		if (-1 == inFile.get())
			break;
		Processnumber++;//线程数自加
	}
	for (int i=0;i<(int)(Processnumber);i++)
	{
		if (process_info[i].ProcessClass=='r')   //创建读者线程
			
			h_process[i]=CreateThread(NULL,0,\
			(LPTHREAD_START_ROUTINE)(R_ReaderProcess),\
			&process_info[i],0,&Process_ID);
		else                                    //创建写者线程
			
			h_process[i]=CreateThread(NULL,0,\
			(LPTHREAD_START_ROUTINE)(R_WriterProcess),\
			&process_info[i],0,&Process_ID);
	}
	waiting_for_all_process=WaitForMultipleObjects(Processnumber,h_process,TRUE,-1);
	printf("\n");
    printf("  已完成所有读者和写者线程操作,请根据提示继续操作 \n");

}
//以下为读者优先--读者线程
void R_ReaderProcess(void *p)
{
	//互斥变量
	HANDLE h_Mutex;
	h_Mutex=OpenMutex(MUTEX_ALL_ACCESS,FALSE,"mutex_for_read_count");
	DWORD m_delay_time;          //延迟时间
	DWORD m_Process__Delay;        //读操作持续时间
	DWORD waiting_for_mutex;   //等待互斥变量所有权
	int m_Process_serial_number;           //线程序号
	m_Process_serial_number=((ProcessInfo *)(p))->Process_serial_number;
	m_delay_time=(DWORD)(((ProcessInfo *)(p))->Process_Start*100);
	m_Process__Delay=(DWORD)(((ProcessInfo *)(p))->Process_Delay*100);
	Sleep(m_delay_time);                                   //延迟等待
	printf("读者 %d  发出读请求.\n",m_Process_serial_number);

//等待互斥对象通知
	waiting_for_mutex=WaitForSingleObject(h_Mutex,-1);   //等待互斥信号，保证对read_count的访问、
													  //修改互斥
	read_count++;                                      //读者数目加一
	if (read_count==1)
		EnterCriticalSection(&RP_Write);//禁止写者进入	          
	ReleaseMutex(h_Mutex);//释放互斥对象，允许下个读者继续读：
	//读操作
	printf("读者 %d  开始读操作.\n",m_Process_serial_number);

	Sleep(m_Process__Delay);
	//退出线程
	printf("读者 %d  完成读操作.\n",m_Process_serial_number);
	
	waiting_for_mutex=WaitForSingleObject(h_Mutex,-1);  //等待互斥信号，保证对read_count的访问、修改互斥
	read_count--;                                     //读者数目减少
	if (read_count==0)
		LeaveCriticalSection(&RP_Write);	         //如果所有读者读完，唤醒写者
	ReleaseMutex(h_Mutex);//释放互斥信号
}
//以下为读者优先--写者线程
void R_WriterProcess(void *p)
{
	int m_Process_serial_number;        //线程序号
	DWORD m_delay_time;          //延迟时间
	DWORD m_Process__Delay;  //读操作持续时间
	
	//从参数中获得信息
	m_Process_serial_number=((ProcessInfo *)(p))->Process_serial_number;
	m_delay_time=(DWORD)(((ProcessInfo *)(p))->Process_Start*100);
	m_Process__Delay=(DWORD)(((ProcessInfo *)(p))->Process_Delay*100);
	Sleep(m_delay_time);                                   //延迟等待
	printf("写者 %d  发出写请求.\n",m_Process_serial_number);

	EnterCriticalSection(&RP_Write);//禁止下一位写者进入
	//写操作
	printf("写者 %d  开始写操作.\n",m_Process_serial_number);

	Sleep(m_Process__Delay);
	//退出线程
    printf("写者 %d  完成写操作.\n",m_Process_serial_number);
	LeaveCriticalSection(&RP_Write);	//如果所有读者读完，唤醒写者
}
//以下为写者优先处理函数
void W_Fun(char* file)
{
	DWORD Process_ID;         //线程ID
	DWORD Processnumber=0;        //线程数目
	DWORD waiting_for_all_process;      //等待所有线程结束
	//互斥对象
	HANDLE h_Mutex1, h_Mutex2, h_Mutex3;
	h_Mutex1 = CreateMutex(NULL, FALSE, "mutex_for_write_count");
	h_Mutex2 = CreateMutex(NULL, FALSE, "mutex_for_read_count");
	h_Mutex3 = CreateMutex(NULL, FALSE, "mutex_for_read");
	//线程对象数组
	HANDLE h_process[64];
	ProcessInfo process_info[64];
	read_count=0;     //初始化read_count
	InitializeCriticalSection(&cs_Write);  //初始化临界区
	InitializeCriticalSection(&cs_Read);
	ifstream inFile;
	inFile.open(file);                     //打开操作
	printf("       写者优先  运行过程:\n");
    printf("\n");
	while (inFile)
	{//读入每一个读者、写者的信息		
		inFile>>process_info[Processnumber].Process_serial_number
    >>process_info[Processnumber].ProcessClass
	>>process_info[Processnumber].Process_Start
    >>process_info[Processnumber].Process_Delay;
	if(-1 == inFile.get())
			break;
		Processnumber++;//线程数自加
	}
	for (int i=0;i<(int)(Processnumber);i++)
	{
		if (process_info[i].ProcessClass=='r')
			//创建读者线程
			h_process[i]=CreateThread(NULL,0,\
			(LPTHREAD_START_ROUTINE)(W_ReaderProcess),\
			&process_info[i],0,&Process_ID);
		else
			//创建写者线程
			h_process[i]=CreateThread(NULL,0,\
			(LPTHREAD_START_ROUTINE)(W_WriterProcess),\
			&process_info[i],0,&Process_ID);
	}
	//等待所有线程结束
	waiting_for_all_process=WaitForMultipleObjects(Processnumber,h_process,TRUE,-1);
	printf("\n");
    printf("  已完成所有读者和写者线程操作，根据提示继续操作!");

}
//以下为写者优先--写者线程
void W_WriterProcess(void *p)
{
	//互斥变量
	HANDLE h_Mutex1;
	h_Mutex1 = OpenMutex(MUTEX_ALL_ACCESS,FALSE,"mutex_for_write_count");
	int m_Process_serial_number;           //线程序号
	DWORD m_delay_time;          //延迟时间
	DWORD m_Process__Delay;        //读操作持时续间
	DWORD waiting_for_mutex;   //等待互斥变量所有权
	m_Process_serial_number=((ProcessInfo *)(p))->Process_serial_number;
	m_delay_time=(DWORD)(((ProcessInfo *)(p))->Process_Start*100);//每秒时钟中断100次
	m_Process__Delay=(DWORD)(((ProcessInfo *)(p))->Process_Delay*100);	Sleep(m_delay_time);   
	printf("写者 %d  发出写请求.\n",m_Process_serial_number);

	waiting_for_mutex=WaitForSingleObject(h_Mutex1,-1);  
	write_count++;
	if (write_count==1)
		EnterCriticalSection(&cs_Read);
	ReleaseMutex(h_Mutex1);
	EnterCriticalSection(&cs_Write);
	printf("写者 %d  开始写操作.\n",m_Process_serial_number);

	Sleep(m_Process__Delay);
    printf("写者 %d  完成写操作.\n",m_Process_serial_number);
	LeaveCriticalSection(&cs_Write);
	waiting_for_mutex=WaitForSingleObject(h_Mutex1,-1);  
	write_count--;
	if(write_count == 0)
		LeaveCriticalSection(&cs_Read);
	ReleaseMutex(h_Mutex1);
}
//以下为写者优先--读者线程
void W_ReaderProcess(void *p)
{
	HANDLE h_Mutex2, h_Mutex3;
	h_Mutex2 = OpenMutex(MUTEX_ALL_ACCESS,FALSE,"mutex_for_read_count");
	h_Mutex3 = OpenMutex(MUTEX_ALL_ACCESS,FALSE,"mutex_for_read");
	DWORD waiting_for_mutex, waiting_for_mutex1; 
//等待互斥变量所有权
	DWORD m_delay_time;          //延迟时间
	DWORD m_Process__Delay;        //读操作持续时间
	int m_Process_serial_number;           //线程序号
	m_Process_serial_number=((ProcessInfo *)(p))->Process_serial_number;
	m_delay_time=(DWORD)(((ProcessInfo *)(p))->Process_Start*100);
	m_Process__Delay=(DWORD)(((ProcessInfo *)(p))->Process_Delay*100);
	Sleep(m_delay_time);
    printf("读者 %d  发出读请求.\n",m_Process_serial_number);
	waiting_for_mutex1=WaitForSingleObject(h_Mutex3,-1);
	EnterCriticalSection(&cs_Read);
	LeaveCriticalSection(&cs_Read);
	ReleaseMutex(h_Mutex3);
	waiting_for_mutex=WaitForSingleObject(h_Mutex2,-1); 
	read_count++;
	if (read_count == 1)
		EnterCriticalSection(&cs_Write);
	ReleaseMutex(h_Mutex2);
    printf("读者 %d  开始读操作.\n",m_Process_serial_number);

	Sleep(m_Process__Delay);

    printf("读者 %d  完成读操作.\n",m_Process_serial_number);
	waiting_for_mutex=WaitForSingleObject(h_Mutex2,-1);
	read_count--;
	if (read_count == 0)
		LeaveCriticalSection(&cs_Write);
	ReleaseMutex(h_Mutex2);
} //结束