?? procucerconsumer.cpp

?? 簡易地演示操作系統方面的一個重要問題——生產者消費者
?? 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;
    // mutex_for_readcount 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);  // 互斥對象， －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("Writer 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("Writer thread %d finishing  writing to the file.\n",m_serial);
	//釋放資源
	LeaveCriticalSection(&RP_Write);
}


/////////////////////////////////////////////////////////
//讀者優先處理函數
// file:文件名
void ReaderPriority(char* file)
{
DWORD n_thread = -1;        //線程數目
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");

//inFile.get();  // Add by BAOyubin
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);
//
wait_for_mutex2 = WaitForSingleObject(h_Mutex2,-1);
//修改讀者數目
readcount++;
if(readcount == 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);
// 
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 begins the write to the file.\n",m_serial);
Sleep(m_persist);
//退出線程
printf("Writer thread %d finishing 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 = -1;
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 or 3):");
//如果輸入信息不正確，繼續輸入
do{
     ch = (char)_getch(); 
}while(ch != '1'&& ch != '2' && ch != '3');

system("cls");
//選者3返回
if (ch == '3') 
    return 0;
	//選擇1，讀者優先
else if(ch == '1')
     ReaderPriority("PC.TXT");
	//選擇2，寫者優先
else if(ch == '2')
     WriterPriority("PC.TXT");
//結束
printf("\npress Any Key To Continue:");
_getch();
system("cls");
}
return 0;
}
?? 文件大小 62 K
?? 上傳用戶 fy8855773
?? 所屬分類數值算法/人工智能
??? 相關標簽

#操作系統 #方面
?? 快捷鍵說明

復制代碼 Ctrl + C
搜索代碼 Ctrl + F
全屏模式 F11
切換主題 Ctrl + Shift + D
顯示快捷鍵 ?
增大字號 Ctrl + =
減小字號 Ctrl + -
亚洲欧美第一页_禁久久精品乱码_粉嫩av一区二区三区免费野_久草精品视频

?? procucerconsumer.cpp

?? 快捷鍵說明
