Question

求一同步对象解决临界区问题的C语言程序

②、设计内容
分别用信号量来模拟实现读者优先和写者优先的读者-写者问题。（实现其中之一）.
信号量实现进程的互斥和同步.
用信号量来模拟实现读、写进程间的互斥。
设置三个读进程A\B\C和三个写进程D\E\F,由进程间互斥可以知道，哪方进程先进入，资源就由谁占用。
③、设计要求
a、使用模块化设计思想来设计；
b、给出算法的流程图或伪码说明。
c、用C语言编写出程序，实现使用信号量的互斥和同步。
④、运行结果
a、显示进程的运行轨迹和执行先后顺序。
⑤、提示
1）写-写互斥；2）读-写互斥；3）读-读允许；
读者优先的附加限制：如果一个读者申请进行读操作时已有另一读者正在进行读操作，则该读者可直接开始读操作。
写者优先的附加限制：如果一个读者申请进行读操作时已有另一写者在等待访问共享资源，则该读者必须等到没有写者处于等待状态后才能开始读操作。
运行结果显示要求：要求在每个线程创建、发出读写操作申请、开始读写操作和结束读写操作时分别显示一行提示信息，以确信所有处理都遵守相应的读写操作限制。
测试数据文件格式
测试数据文件包括n 行测试数据，分别描述创建的n 个线程是读者还是写者，以及读写操作的开始时间和持续时间。每行测试数据包括四个字段，各字段间用空格分隔。第一字段为一个正整数，表示线程序号。第二字段表示相应线程角色，R 表示读者是，W 表示写者。第三字段为一个正数，表示读写操作的开始时间。线程创建后，延时相应时间（单位为秒）后发出对共享资源的读写申请。第四字段为一个正数，表示读写操作的持续时间。当线程读写申请成功后，开始对共享资源的读写操作，该操作持续相应时间后结束，并释放共享资源。
下面是一个测试数据文件的例子：
1 R 3 5
2 W 4 5
3 R 5 2
4 R 6 5
5 W 5.1 3
与实验相关的API 介绍
线程控制：
CreateThread 完成线程创建，在调用进程的地址空间上创建一个线程，以执行指定的函数；它的返回值为所创建线程的句柄。
HANDLE CreateThread（
LPSECURITY_ATTRIBUTES lpThreadAttributes, // SD
DWORD dwStackSize, // initial stack size
LPTHREAD_START_ROUTINE lpStartAddress, // thread
function
LPVOID lpParameter, // thread argument
DWORD dwCreationFlags, // creation option
LPDWORD lpThreadId // thread identifier）;
ExitThread 用于结束当前线程。
VOID ExitThread（
DWORD dwExitCode // exit code for this thread）;
Sleep 可在指定的时间内挂起当前线程。
VOID Sleep（
DWORD dwMilliseconds // sleep time）;
信号量控制：
CreateMutex 创建一个互斥对象，返回对象句柄；
HANDLE CreateMutex（
LPSECURITY_ATTRIBUTES lpMutexAttributes, // SD
BOOL bInitialOwner, // initial owner
LPCTSTR lpName // object name）;
OpenMutex 打开并返回一个已存在的互斥对象句柄，用于后续访问；
HANDLE OpenMutex（
DWORD dwDesiredAccess, // access
BOOL bInheritHandle, // inheritance option
LPCTSTR lpName // object name）;
ReleaseMutex 释放对互斥对象的占用，使之成为可用。
BOOL ReleaseMutex（HANDLE hMutex // handle to mutex）;
WaitForSingleObject 可在指定的时间内等待指定对象为可用状态；
DWORD WaitForSingleObject（
HANDLE hHandle, // handle to object
DWORD dwMilliseconds // time-out interval）;
程序使用C语言或者C++都可以，并请对程序作必要注释，其它语言不要，请高手帮忙，如果能够编译通过再送100分

Answer 1

// 最近正好也关注这个问题，下面是我的实现，主要参考自windows 内核实验教程

#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 // 最大线程数

int nReaderCnt = 0; // 读者计数
int nWriterCnt = 0; // 写者计数

// 使用信号量代替临界区
HANDLE hWrite = ::CreateSemaphore( NULL, 1, 1, NULL ); // 写开始信号
HANDLE hRead = ::CreateSemaphore( NULL, 1, 1, NULL ); // 读开始信号

// 计数器的互斥保护
HANDLE hRCMutex = ::CreateMutex( NULL, FALSE, NULL );
HANDLE hWCMutex = ::CreateMutex( NULL, FALSE, NULL );

// 在写优先中读信号
HANDLE hReadMutex = ::CreateMutex( NULL, FALSE, NULL );

// 从测试数据文件中获取的线程信息
struct ThreadInfo
{
ThreadInfo()
{
nSerialNo = 0;
cType = '^';
dDelayTime = 0.0;
dOpeTime = 0.0;
}
int nSerialNo; // 线程序号
char cType; // 线程类别(判断是读者还是写者线程)
double dDelayTime; // 线程延迟时间
double dOpeTime; // 线程读写操作时间
};

///////////////////////////////////////////////////////////////////////////
// 读者优先---读者线程
// P:读者线程信息
void RP_ReaderThread(void *p)
{
// 线程序号
int nSerialNo = ((ThreadInfo*)(p))->nSerialNo ;
DWORD dwReadTime = (DWORD)(((ThreadInfo*)(p))->dOpeTime * INTE_PER_SEC );
DWORD dwDelay = (DWORD)(((ThreadInfo*)(p))->dDelayTime * INTE_PER_SEC );

Sleep( dwDelay );
printf("Reader thread %d sents the reading require.\n",nSerialNo);

// 读者数目增加
WaitForSingleObject( hRCMutex, INFINITE );
nReaderCnt++;
if( nReaderCnt == 1 )
{
// 第一个读者, 写保护信号，实现读写互斥
WaitForSingleObject( hWrite, INFINITE );
}
ReleaseMutex(hRCMutex);

// 读文件
printf( "Reader thread %d begins to read file.\n", nSerialNo );
Sleep( dwReadTime );
printf( "Reader thread %d finished reading file.\n", nSerialNo );

// 读者数目减少
WaitForSingleObject( hRCMutex, INFINITE );
nReaderCnt--;
if( nReaderCnt == 0 )
{
// 如果所有的读者读完, 释放写保护信号
ReleaseSemaphore( hWrite, 1, NULL );
}
ReleaseMutex(hRCMutex);
}

//////////////////////////////////////////////////////////////
// 读者优先---写者线程
// P:写者线程信息
void RP_WriterThread(void *p)
{
// 从参数中获得信息
int nSerialNo = ((ThreadInfo*)(p))->nSerialNo ;
DWORD dwWriteTime = (DWORD)(((ThreadInfo*)(p))->dOpeTime * INTE_PER_SEC );
DWORD dwDelay = (DWORD)(((ThreadInfo*)(p))->dDelayTime * INTE_PER_SEC );

Sleep( dwDelay );
printf("Write thread %d sents the writing require.\n",nSerialNo);

// 写保护信号
WaitForSingleObject( hWrite, INFINITE );

//写文件
printf( "Writer thread %d begins to write to the file.\n", nSerialNo );
Sleep( dwWriteTime );
printf( "Write thread %d finished writing to the file.\n", nSerialNo );

ReleaseSemaphore( hWrite, 1, NULL );
}

//////////////////////////////////////////////////////////////
// 读者优先处理函数
// file:文件名
void ReaderPriority( char *file )
{
//线程数目
int nThreadCnt = 0;
//线程ID
DWORD dwThreadID = 0;

// 初始化读写者计数
nReaderCnt = 0;

// 线程对象的数组
HANDLE hThreads[MAX_THREAD_NUM];
ThreadInfo oThreadInfo[MAX_THREAD_NUM];
ifstream inFile;
inFile.open ( file );
printf( "Reader Priority:\n\n" );
while( inFile )
{
// 读入每一个读者,写者的信息
inFile>>oThreadInfo[nThreadCnt].nSerialNo;
inFile>>oThreadInfo[nThreadCnt].cType;
inFile>>oThreadInfo[nThreadCnt].dDelayTime;
inFile>>oThreadInfo[nThreadCnt].dOpeTime;
if ( '^' != oThreadInfo[nThreadCnt].cType )
{
nThreadCnt++;
}
inFile.get();
}

// 创建线程
for( int i = 0; i< nThreadCnt; i++ )
{
if(( oThreadInfo[i].cType==READER ) || ( oThreadInfo[i].cType == 'r' ))
{
// 创建读者进程
hThreads[i] = CreateThread( NULL, 0, (LPTHREAD_START_ROUTINE)(RP_ReaderThread),
&oThreadInfo[i], CREATE_SUSPENDED, &dwThreadID );
}
else
{
// 创建写线程
hThreads[i] = CreateThread( NULL, 0,(LPTHREAD_START_ROUTINE)(RP_WriterThread),
&oThreadInfo[i], CREATE_SUSPENDED, &dwThreadID );
}
}

// 启动线程
for( i = 0; i< nThreadCnt; i++ )
{
ResumeThread( hThreads[i] );
}

// 等待所有的线程结束
WaitForMultipleObjects( nThreadCnt, hThreads, TRUE, INFINITE );
printf( "All reader and writer have finished operating.\n" );

}

////////////////////////////////////////////////////////
// 写者优先---读者线程
// P:读者线程信息
void WP_ReaderThread( void *p )
{
// 从参数中得到信息
int nSerialNo = ((ThreadInfo*)(p))->nSerialNo ;
DWORD dwReadTime = (DWORD)(((ThreadInfo*)(p))->dOpeTime * INTE_PER_SEC );
DWORD dwDelay = (DWORD)(((ThreadInfo*)(p))->dDelayTime * INTE_PER_SEC );

Sleep( dwDelay );
printf("Reader thread %d sents the reading require.\n",nSerialNo);

// 读信号互斥保护
WaitForSingleObject( hReadMutex, INFINITE );
// 读信号
WaitForSingleObject( hRead, INFINITE );
// 增加读者计数
WaitForSingleObject( hRCMutex, INFINITE );
nReaderCnt++;
if(nReaderCnt==1)
{
// 如果是第1个读者, 写信号，以实现读写互斥
WaitForSingleObject( hWrite, INFINITE );
}
ReleaseMutex( hRCMutex );
ReleaseSemaphore( hRead, 1, NULL );
ReleaseMutex( hReadMutex );

// 读文件
printf( "Reader thread %d begins to read file.\n", nSerialNo );
Sleep( dwReadTime );
printf( "Reader thread %d finished reading file.\n", nSerialNo );

// 减少读者计数
WaitForSingleObject( hRCMutex, INFINITE );
nReaderCnt--;
if( nReaderCnt == 0 )
{
// 最后一个读者, 唤醒写者
ReleaseSemaphore( hWrite, 1, NULL );
}
ReleaseMutex( hRCMutex );
}

///////////////////////////////////////////
// 写者优先---写者线程
// P:写者线程信息
void WP_WriterThread( void *p )
{
//从参数中获得信息
int nSerialNo = ((ThreadInfo*)(p))->nSerialNo;
DWORD dwWriteTime = (DWORD)(((ThreadInfo*)(p))->dOpeTime * INTE_PER_SEC );
DWORD dwDelay = (DWORD)(((ThreadInfo*)(p))->dDelayTime * INTE_PER_SEC );

Sleep( dwDelay );
printf("Writer thread %d sents the writing require.\n",nSerialNo);

// 增加写者计数
WaitForSingleObject( hWCMutex, INFINITE );
nWriterCnt++;
if( nWriterCnt == 1 )
{
// 为实现写者优先，获取读信号，从而阻塞读线程
WaitForSingleObject( hRead, INFINITE );
}
ReleaseMutex(hWCMutex);

// 写信号
WaitForSingleObject( hWrite, INFINITE );
printf( "Writer thread %d begins to write to the file.\n", nSerialNo );
Sleep( dwWriteTime );
printf( "Writer thread %d finished writing to the file.\n", nSerialNo );
ReleaseSemaphore( hWrite, 1, NULL );

// 减少写者计数
WaitForSingleObject( hWCMutex, INFINITE );
nWriterCnt--;
if( nWriterCnt == 0 )
{
ReleaseSemaphore( hRead, 1, NULL );
}
ReleaseMutex(hWCMutex);
}

/////////////////////////////////////////////
// 写者优先处理函数
// file:文件名
void WriterPriority( char * file )
{
int nThreadCnt = 0;
DWORD dwThreadID;

HANDLE hThreads[MAX_THREAD_NUM];
ThreadInfo oThreadInfo[MAX_THREAD_NUM];

nReaderCnt=0;
nWriterCnt=0;

ifstream inFile;
inFile.open (file);
printf("Writer priority:\n\n");
while(inFile)
{
inFile>>oThreadInfo[nThreadCnt].nSerialNo;
inFile>>oThreadInfo[nThreadCnt].cType;
inFile>>oThreadInfo[nThreadCnt].dDelayTime;
inFile>>oThreadInfo[nThreadCnt].dOpeTime;
if ( '^' != oThreadInfo[nThreadCnt].cType )
{
nThreadCnt++;
}
inFile.get();
}

// 创建线程
for( int i = 0 ;i < nThreadCnt; i++ )
{
if(( oThreadInfo[i].cType == READER ) || ( oThreadInfo[i].cType == 'r' ))
{
//创建读者进程
hThreads[i] = CreateThread( NULL, 0, (LPTHREAD_START_ROUTINE)(WP_ReaderThread),
&oThreadInfo[i], CREATE_SUSPENDED, &dwThreadID );
}
else
{
//创建写线程
hThreads[i] = CreateThread( NULL, 0, (LPTHREAD_START_ROUTINE)(WP_WriterThread),
&oThreadInfo[i],CREATE_SUSPENDED,&dwThreadID);
}
}

// 启动线程
for( i = 0; i< nThreadCnt; i++ )
{
ResumeThread( hThreads[i] );
}

// 等待所有的线程结束
WaitForMultipleObjects( nThreadCnt, hThreads, TRUE, INFINITE );

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;
}