Windows操作系统实习之读者写者问题

Visual Studio 2008

参考（http://blog.csdn.net/melody_1208/article/details/2027507）

在Windows 下创建一个控制台进程，该进程应包含n个线程。用这n个线程来表示n个读者或写者。每个线程按相应测试数据文件(后面介绍)的要求进行读写操作。用信号量机制分别实现读者优先和写者优先的读者-写者问题。

读者-写者问题的操作限制(包括读者优先和写者优先)：

1）写-写互斥，即不能有两个写者同时进行写操作。

2）读-写互斥，即不能同时有一个线程在读，而另一个线程在写。

3）读-读互斥，即可以有一个或多个读者在读。

读者优先的附加限制：如果一个读者申请进行读操作时已有另一个读者正在进行读操作，则该读者可直接开始读操作。

写者优先的附加限制：如果一个读者申请进行读操作时已有另一个写者在等待访问共享资源，则该读者必须等到没有写者出于等待状态后才能开始读操作。

测试文件格式说明，下面是一个测试数据文件的例子：

1 R 3 5
2 W 4 5
3 R 5 2
4 R 6 5
5 W 5.1 3
6 R 15 4
7 R 15 4

#include <Windows.h>
#include <conio.h>
#include <cstdlib>
#include <stdio.h>
#include <fstream>
using namespace std;

#define READER 'R'    
#define WRITER 'W'
#define INTE_PER_SEC 1000    //interrupt number per second
#define MAX_THREAD_NUM 64    //max thread number

int readCount = 0;
int writeCount = 0;

CRITICAL_SECTION RP_Writer; //Critical Section
CRITICAL_SECTION cs_Writer;
CRITICAL_SECTION cs_Read;

struct ThreadInfo
{
    int serial;    //the serial number of the thread
    char entity;    //type of thread(reader or writer)
    double delay;    //delay of thread
    double persist;    //time of thread's read and write operation
};

void RP_ReaderThread(void *p);
void RP_WriterThread(void *p);
void ReaderPriority(char *file);

void WP_ReaderThread(void *p);
void WP_WriterThread(void *p);
void WriterPriority(char *file);

int main()
{
    char ch;
    while (true)
    {
        printf("*************************************************\n");
        printf(" 1: Read Priority\n");
        printf(" 2: Writer Priority \n");
        printf(" 3: Exit\n");
        printf("*************************************************\n");
        printf("Enter your choice(1, 2 or 3)\n");

        //input is incorrect
        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 Continue:\n");
        _getch();
        //system("cls");
    }
    return 0;
}

void RP_ReaderThread(void *p)
{
    //execlusive object
    HANDLE h_Mutex;
    h_Mutex = OpenMutex(MUTEX_ALL_ACCESS, FALSE, "mutex_for_readCount");

    DWORD wait_for_mutex;    //wait for the execlusive object
    DWORD m_delay;    //delay time
    DWORD m_persist;    //the time of read file operation
    int m_serial;    //serical number of the thread

    //get the information from the parameter
    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);    //wait for a little while

    printf("Reader thread %d sents the reading require \n", m_serial);

    wait_for_mutex = WaitForSingleObject(h_Mutex, -1);

    readCount++;
    if (readCount == 1)
    {
        //the first reader, wait for resource
        EnterCriticalSection(&RP_Writer);
    }
    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);
    wait_for_mutex = WaitForSingleObject(h_Mutex, -1);
    readCount--;
    if (readCount == 0)
    {
        //if all readers finished their operation, wake up the writer
        LeaveCriticalSection(&RP_Writer);
        printf("Reader thread %d leave the critical section\n", m_serial);
    }
    ReleaseMutex(h_Mutex);
}

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_Writer);

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

void ReaderPriority(char *file)
{
    DWORD n_thread = 0; //number of threads
    DWORD thread_ID; //thread ID
    DWORD wait_for_all;    //wait for all threads

    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;    //initialize readcount
    InitializeCriticalSection(&RP_Writer);
    fstream inFile;
    inFile.open(file);
    printf("Read Priority \n\n");
    while(inFile)
    {
        //Read every writer, reader's information
        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')
        {
            //create reader thread
            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 thread to terminate
    wait_for_all = WaitForMultipleObjects(n_thread, h_Thread, TRUE, -1);
    printf("All reader and writer have finished operating \n");
}

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;    //latency time
    DWORD m_persist;    //the time it used for reading the file
    int m_serial;    //the serial number of the thread

    //get information from the parameter
    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 sends the reading require \n", m_serial);
    wait_for_mutex1 = WaitForSingleObject(h_Mutex1, -1);

    //enter the reader's critical section
    EnterCriticalSection(&cs_Read);

    //block execlusive object mutex2, ensure the access, modify to readcount is execlusive
    wait_for_mutex2 = WaitForSingleObject(h_Mutex2, -1);
    readCount++;
    if (readCount == 1)
    {
        //if it is the first reader, wait for the writer finish
        EnterCriticalSection(&cs_Writer);
    }
    ReleaseMutex(h_Mutex2);

    //let other reader enter the critical section
    LeaveCriticalSection(&cs_Read);
    ReleaseMutex(h_Mutex1);

    //read file
    printf("Reader thread %d begins to read file \n", m_serial);
    //block exevlusive object mutex2, ensure the access, modify to readcount is execlusive
    wait_for_mutex2 = WaitForSingleObject(h_Mutex2, -1);
    readCount--;
    if (readCount == 0)
    {
        //the last reader, wake up writer
        LeaveCriticalSection(&cs_Writer);
    }
    ReleaseMutex(h_Mutex2);
}

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");

    //get information from the parameter
    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 sends the writing require\n", m_serial);

    wait_for_mutex3 = WaitForSingleObject(h_Mutex3, -1);
    writeCount++;
    if (writeCount == 1)
    {
        //the first writer, wait for the read finsih
        EnterCriticalSection(&cs_Read);
    }
    ReleaseMutex(h_Mutex3);

    //enter the writer critical section
    EnterCriticalSection(&cs_Writer);

    //write the file
    printf("Write thread %d begins to write to the file \n", m_serial);
    Sleep(m_persist);

    //exit the thread
    printf("Write thread %d finishing writing to the file\n", m_serial);
    //leave the critical section
    LeaveCriticalSection(&cs_Writer);

    wait_for_mutex3 = WaitForSingleObject(h_Mutex3, -1);
    writeCount--;
    if (writeCount == 0)
    {
        //writer finished, reader can read
        LeaveCriticalSection(&cs_Read);
    }
    ReleaseMutex(h_Mutex3);
}

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");

    //thread object
    HANDLE h_Thread[MAX_THREAD_NUM];
    ThreadInfo thread_info[MAX_THREAD_NUM];

    readCount = 0;
    writeCount = 0;
    InitializeCriticalSection(&cs_Writer);
    InitializeCriticalSection(&cs_Read);
    fstream inFile;
    inFile.open(file);
    printf("Write 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')
        {
            //create reader thread
            h_Thread[i] = CreateThread(NULL, 0,
                                    (LPTHREAD_START_ROUTINE)(WP_ReaderThread),
                                    &thread_info[i],
                                    0,
                                    &thread_ID);
        }
        else
        {
            //create writer thread
            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");
}