读者写者问题 ----写者优先

#include \"windows.h\"

#include

#include

#include

#include

#include

#include

#define INTE_PER_SEC 1000 #define MAX_THREAD_NUM 64 #define MAX_FILE_NUM 32 #define MAX_STR_LEN 32 FILE * file;

//每秒时钟中断的数目//最大线程数

//最大文件数目数

//字符串的长度

FILE * inFile;

int readcount=0; //读者数目

int writecount=0; //写者数目

//临界资源

CRITICAL_SECTION cs_Write;

CRITICAL_SECTION cs_Read;

struct ThreadInfo

{ int serial; //线程序号

char entity; //线程类别(判断是读者还是写者线程)

double delay; //线程延迟时间

double persist; //线程读写操作时间

};

//写者优先---读者线程

//P:读者线程信息

void WP_ReaderThread(void *p)

{

//互斥变量

HANDLE h_Mutex1=OpenMutex(MUTEX_ALL_ACCESS,FALSE,\"mutex1\");

HANDLE h_Mutex2=OpenMutex(MUTEX_ALL_ACCESS,FALSE,\"mutex2\");

DWORD wait_for_mutex1; //等待互斥变量所有权

DWORD wait_for_mutex2;

DWORD m_delay=(DWORD)(((ThreadInfo*)(p))->delay *INTE_PER_SEC); //延迟时间

DWORD m_persist=(DWORD)(((ThreadInfo*)(p))->persist *INTE_PER_SEC); //读文件持续时间

int m_serial=((ThreadInfo*)(p))->serial ; //线程的序号

Sleep(m_delay); //延迟等待

printf(\"Reader thread %d sents the reading require.\\n\

fprintf(file,\"Reader thread %d sents the reading require.\\n\

wait_for_mutex1=WaitForSingleObject(h_Mutex1,-1);

EnterCriticalSection(&cs_Read); //读者进去临界区

//阻塞互斥对象Mutex2,保证对readCount的访问和修改互斥

wait_for_mutex2=WaitForSingleObject(h_Mutex2,-1);

readcount++;

if(readcount==1)

{ // 如果是第1个读者,等待写者写完

EnterCriticalSection(&cs_Write);

}

ReleaseMutex(h_Mutex2);// 释放互斥信号 Mutex2

//让其他读者进去临界区

LeaveCriticalSection(&cs_Read);

ReleaseMutex(h_Mutex1);

//读文件

printf(\"Reader thread %d begins to read file.\\n\

fprintf(file,\"Reader thread %d begins to read file.\\n\

Sleep(m_persist);

//退出线程

printf(\"Reader thread %d finished reading file.\\n\

fprintf(file,\"Reader thread %d finished reading file.\\n\

//阻塞互斥对象Mutex2,保证对readcount的访问,修改互斥

wait_for_mutex2=WaitForSingleObject(h_Mutex2,-1);

readcount--;

if(readcount==0)

{ //最后一个读者,唤醒写者

LeaveCriticalSection(&cs_Write);

}

ReleaseMutex(h_Mutex2); //释放互斥信号

}

///////////////////////////////////////////

//写者优先---写者线程

//P:写者线程信息

void WP_WriterThread(void *p)

{

DWORD wait_for_mutex3; //互斥变量

DWORD m_delay; //延迟时间

DWORD m_persist; //读文件持续时间

int m_serial; //线程序号

HANDLE 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 reading require.\\n\

fprintf(file,\"Writer thread %d sents the reading require.\\n\

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 to write to the file.\\n\

fprintf(file,\"Writer thread %d begins to write to the file.\\n\

Sleep(m_persist);

printf(\"Writer thread %d finished writing to the file.\\n\

fprintf(file,\"Writer thread %d finished writing to the file.\\n\

LeaveCriticalSection(&cs_Write);

wait_for_mutex3=WaitForSingleObject(h_Mutex3,-1);

writecount--;

if(writecount==0)

{

LeaveCriticalSection(&cs_Read);

}

ReleaseMutex(h_Mutex3);

}

/////////////////////////////////////////////

//写者优先处理函数

// file:文件名

int main(int argc,char *argv[])

{

DWORD n_thread=0;

DWORD thread_ID;

DWORD wait_for_all;

HANDLE h_Mutex1=CreateMutex(NULL,FALSE,\"mutex1\");

HANDLE h_Mutex2=CreateMutex(NULL,FALSE,\"mutex2\");

HANDLE h_Mutex3=CreateMutex(NULL,FALSE,\"mutex3\");

HANDLE h_Thread[MAX_THREAD_NUM];

ThreadInfo thread_info[MAX_THREAD_NUM];

InitializeCriticalSection(&cs_Write);

InitializeCriticalSection(&cs_Read);

int a;

char c;

int b;

int d;

file=fopen(\"thread.txt\

if(file!=NULL){

while(!feof(file)){

fscanf(file,\"%d %c %d%d\\n\

&b,&d);

thread_info[n_thread].serial=a;

thread_info[n_thread].delay=b;

thread_info[n_thread].entity=c;

thread_info[n_thread++].persist=d;

}

}

fclose(file);

if((file=fopen(\"output.txt\

cout<<\"can not open the output.txt file\"<}

fprintf(file,\"%s\

for(int i=0;i<(int)(n_thread);i++)

{

if(thread_info[i].entity=='R'||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\");

fclose(file);

return 0;

}