// 来自:windows 内核实验教程
// 机械工业出版社
// ISBN:7-111-10880-9/TP.2600
// 制作者:yuhejun@126.com
// For more information:www.surstar.com
// 2005.11.9
// beijing changping
// Debug Vision
// Description:这是一个关于操作系统内核实验的一段程序,读者和写者的问题的模拟实现.
// 开发环境:WINXP +VC6 Console Application
// 修改者:xiejh_buaa@163.com
// 修改时间: 2007-11-25
// 修改描述: 将代码中的Critical Section改为了信号量
#include "windows.h"
#include <conio.h>
#include <stdlib.h>
#include <fstream.h>
#include <io.h>
#include <string.h>
#include <stdio.h>
#include "winbase.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;
//
// 使用信号量代替临界区
HANDLE g_hSemophore1 = ::CreateSemaphore( NULL, 1, 1, NULL );
HANDLE g_hSemophore2 = ::CreateSemaphore( NULL, 1, 1, NULL );
HANDLE g_hSemophore3 = ::CreateSemaphore( NULL, 1, 1, NULL );
struct ThreadInfo
{
int serial; //线程序号
char entity; //线程类别(判断是读者还是写者线程)
double delay; //线程延迟时间
double persist; //线程读写操作时间
};
///
// 读者优先---读者线程
//P:读者线程信息
void RP_ReaderThread(void *p)
{
//互斥变量
HANDLE h_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);
//读者数目增加
readcount++;
if(readcount==1)
{
//第一个读者,等待资源
WaitForSingleObject( g_hSemophore1, -1 );
}
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)
{
//如果所有的读者读完,唤醒写者
ReleaseSemaphore( g_hSemophore1, 1, NULL );
}
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("Write thread %d sents the writing require./n",m_serial);
//等待资源
WaitForSingleObject( g_hSemophore1, -1 );
//写文件
printf("Writer thread %d begins to write to the file./n",m_serial);
Sleep(m_persist);
//退出线程
printf("Write thread %d finished writing to the file./n",m_serial);
//释放资源
ReleaseSemaphore( g_hSemophore1, 1, NULL );
}
//
//读者优先处理函数
//file:文件名
void ReaderPriority(char *file)
{
DWORD n_thread=0; //线程数目
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
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;
inFile.get();
}
for(int i=0;i<(int)(n_thread-1);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);
//读者进去临界区
WaitForSingleObject( g_hSemophore3, -1 );
//阻塞互斥对象Mutex2,保证对readCount的访问和修改互斥
wait_for_mutex2=WaitForSingleObject(h_Mutex2,-1);
//修改读者的数目
readcount++;
if(readcount==1)
{
// 如果是第1个读者,等待写者写完
WaitForSingleObject( g_hSemophore2, -1 );
}
ReleaseMutex(h_Mutex2);// 释放互斥信号 Mutex2
//让其他读者进去临界区
ReleaseSemaphore( g_hSemophore3, 1, NULL );
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);
//阻塞互斥对象Mutex2,保证对readcount的访问,修改互斥
wait_for_mutex2=WaitForSingleObject(h_Mutex2,-1);
readcount--;
if(readcount==0)
{
//最后一个读者,唤醒写者
ReleaseSemaphore( g_hSemophore2, 1, NULL );
}
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;
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)
{
WaitForSingleObject( g_hSemophore3, -1 );
}
ReleaseMutex(h_Mutex3);
WaitForSingleObject( g_hSemophore2, -1 );
printf("Writer thread %d begins to write to the file./n",m_serial);
Sleep(m_persist);
printf("Writer thread %d finished writing to the file./n",m_serial);
ReleaseSemaphore( g_hSemophore2, 1, NULL );
wait_for_mutex3=WaitForSingleObject(h_Mutex3,-1);
writecount--;
if(writecount==0)
{
ReleaseSemaphore( g_hSemophore3, 1, NULL );
}
ReleaseMutex(h_Mutex3);
}
/
//写者优先处理函数
// file:文件名
void WriterPriority(char * file)
{
DWORD n_thread=0;
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;
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-1);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,3): ");
do{
ch=(char)_getch();
}while(ch!='1'&&ch!='2'&&ch!='3');
system("cls");
if(ch=='3')
return 0;
else if(ch=='1')
ReaderPriority("thread.dat");
else
WriterPriority("thread.dat");
printf("/nPress Any Key to Coutinue:");
_getch();
system("cls");
}
return 0;
}