操作系统课设：读者-写者问题 (C语言 Win10下实现)

要求实现：

1. 创建一个控制台进程，此进程包含n个线程。用这n个线程来表示n个读者或写者。每个线程按相应测试数据文件的要求进行读写操作。用信号量机制分别实现读者优先和写者优先的读者-写者问题。
2. 读者-写者问题的读写操作限制(包括读者优先和写者优先)：
   1. 写-写互斥，即不能有两个写者同时进行写操作。
   2. 读-写互斥，即不能同时有一个线程在读，而另一个线程在写。
   3. 即可以有一个或多个读者在读。
3. 读者优先的附加限制：如果一个读者申请进行读操作时已有另一个读者正在进行读操作，则该读者可直接开始读操作。
4. 写者优先的附加限制：如果一个读者申请进行读操作时已有另一写者在等待访问共享资源，则该读者必须等到没有写者处于等待状态后才能开始读操作。
5. 运行结果显示要求：要求在每个线程创建、发出读写操作申请、开始读写操作和结束读写操作时分别显示一行提示信息，以确定所有处理都遵守相应的读写操作限制。

测试数据文件格式：

测试数据文件包括n行测试数据，分别描述创建的n个线程是读者还是写者，以及读写操作的开始时间和持续时间。每行测试数据包括四个字段，各个字段间用空格分隔。第一字段为一个正整数，表示线程序号。第二字段表示相应线程角色，R表示读者，W表示写者。第三字段为一个正数，表示读写操作的开始时间：线程创建后，延迟相应时间(单位为秒)后发出对共享资源的读写申请。第四字段为一个正数，表示读写操作的持续时间。当线程读写申请成功后，开始对共享资源的读写操作，该操作持续相应时间后结束，并释放共享资源。

下面是一个测试数据文件的例子：

2 W 4 5

3 R 5 2

4 R 6 5

  5 W 5.1 3

注意：在创建数据文件时，由于涉及到文件格式问题，最好在记事本中手工逐个键入数据，而不要拷贝粘贴数据，否则，本示例程序运行时可能会出现不可预知的错误。

实验环境：

• Windows 10 操作系统
• Visual Studio 2017

代码：

用信号量实现，可先写出P/V操作的伪代码，再根据伪代码翻译C代码。

Windows 操作系统中信号量相关的Api有，CreateSemaphore、WaitForSingleObject、ReleaseSemaphore，分别对应创建信号量，P操作、V操作。

可先预先定义好宏，这样在后面写代码的时候就不需要关注 Windows 的具体实现细节了，直接使用P/V操作来编写代码。

写的时间要注意，P/V操作是要成对出现的，否则程序会卡住永远无法被唤醒，最后记得关闭所有句柄来回收资源。

读者优先：

//读者写者问题：读者优先. windows
#include <windows.h>
#include <stdio.h>
#include <time.h>

DWORD dwID;

#define C(S) CreateSemaphore(NULL, 1, 3, (S)) 
#define P(S) WaitForSingleObject((S), INFINITE)
#define V(S) ReleaseSemaphore((S), 1, NULL)
#define CT(func, args) CreateThread(NULL, 0, (func), (args), 0, &dwID)
#define PM(num, S) WaitForMultipleObjects((num), (S), 1, INFINITE)


struct TInfo
{
    int id;
    char type;
    double s;
    double d;
};
typedef struct TInfo TInfo;

TInfo threads[100];
HANDLE hThread[100];
HANDLE s1, s2;
int c = 0;
int Reader_Count = 0;

int Read_TInfo();
void RP();
DWORD WINAPI Reader(LPVOID lpParam);
DWORD WINAPI Writer(LPVOID lpParam);

// 读取测试数据
int Read_TInfo()
{
    FILE* fp;
    errno_t err = fopen_s(&fp, "in.txt", "r");
    if (err != 0) {
        perror("无法打开文件");
        return 0;
    }
    while (fscanf_s(fp, "%d %c %lf %lf", &threads[c].id,
        &threads[c].type, 1, &threads[c].s, &threads[c].d) != EOF) {
        c++;
    }
    fclose(fp);
    return 1;
}

// 读者线程
DWORD WINAPI Reader(LPVOID lpParam)
{
    TInfo* arg = (TInfo*)lpParam;
    Sleep(arg->s * 1000);
    P(s1);
    if (Reader_Count == 0) {
        P(s2);
    }
    Reader_Count++;
    V(s1);
    printf("线程 %d 正在读!\n", arg->id);
    Sleep(arg->d * 1000);
    printf("线程 %d 读完了!\n", arg->id);
    P(s1);
    Reader_Count--;
    if (Reader_Count == 0) {
        V(s2);
    }
    V(s1);
    return 0;
}

// 写者线程
DWORD WINAPI Writer(LPVOID lpParam)
{
    TInfo* arg = (TInfo*)lpParam;
    Sleep(arg->s * 1000);
    P(s2);
    printf("线程 %d 正在写!\n", arg->id);
    Sleep(arg->d * 1000);
    printf("线程 %d 写完了!\n", arg->id);
    V(s2);
    return 0;
}

// 读者优先
void RP()
{
    s1 = C("sig1");
    s2 = C("sig2");
    for (int i = 0; i < c; ++i) {
        if (threads[i].type == 'W') {
            hThread[i] = CT(Writer, &threads[i]);
        }
        else {
            hThread[i] = CT(Reader, &threads[i]);
        }
    }
    PM(c, hThread); //等待所有线程结束
}

int main()
{
    int res = Read_TInfo();
    if (!res) {
        return -1;
    }
    RP();
    for (int i = 0; i < c; ++i) {
        CloseHandle(hThread[i]);
    }
    CloseHandle(s1);
    CloseHandle(s2);
    return 0;
}

其中s1信号量用来保护 Reader_Count 计数器，s2信号量用来在有读者的时候阻塞写者。

写者优先：

相比读者优先要多加两个信号量，一个写者计数器来计数写者。

s3用来保护 Writer_Count，s4用来在有写者的时候阻塞读者。

//读者写者问题：写者优先. windows
#include <windows.h>
#include <stdio.h>
#include <time.h>

DWORD dwID;

#define C(S) CreateSemaphore(NULL, 1, 3, (S)) 
#define P(S) WaitForSingleObject((S), INFINITE)
#define V(S) ReleaseSemaphore((S), 1, NULL)
#define CT(func, args) CreateThread(NULL, 0, (func), (args), 0, &dwID)
#define PM(num, S) WaitForMultipleObjects((num), (S), 1, INFINITE)


struct TInfo
{
    int id;
    char type;
    double s;
    double d;
};
typedef struct TInfo TInfo;

TInfo threads[100];
HANDLE hThread[100];
HANDLE s1, s2, s3, s4;
int c = 0;
int Reader_Count = 0;
int Writer_Count = 0;

int Read_TInfo();
void WP();
DWORD WINAPI Reader(LPVOID lpParam);
DWORD WINAPI Writer(LPVOID lpParam);

// 读取测试数据
int Read_TInfo()
{
    FILE* fp;
    errno_t err = fopen_s(&fp, "in.txt", "r");
    if (err != 0) {
        perror("无法打开文件");
        return 0;
    }
    while (fscanf_s(fp, "%d %c %lf %lf", &threads[c].id,
        &threads[c].type, 1, &threads[c].s, &threads[c].d) != EOF) {
        c++;
    }
    fclose(fp);
    return 1;
}

// 读者线程
DWORD WINAPI Reader(LPVOID lpParam)
{
    TInfo* arg = (TInfo*)lpParam;
    Sleep(arg->s * 1000);
    P(s4); // 等待写者信号量
    P(s1);
    if (Reader_Count == 0) {
        P(s2);
    }
    Reader_Count++;
    V(s1);
    V(s4); // 释放写者信号量
    printf("线程 %d 正在读!\n", arg->id);
    Sleep(arg->d * 1000);
    printf("线程 %d 读完了!\n", arg->id);
    P(s1);
    Reader_Count--;
    if (Reader_Count == 0) {
        V(s2);
    }
    V(s1);
    return 0;
}

// 写者线程
DWORD WINAPI Writer(LPVOID lpParam)
{
    TInfo* arg = (TInfo*)lpParam;
    Sleep(arg->s * 1000);
    P(s3); // 增加写者计数
    if (Writer_Count == 0) {
        P(s4); // 阻止新的读者进入
    }
    Writer_Count++;
    V(s3);
    P(s2);
    printf("线程 %d 正在写!\n", arg->id);
    Sleep(arg->d * 1000);
    printf("线程 %d 写完了!\n", arg->id);
    V(s2);
    P(s3); // 减少写者计数
    Writer_Count--;
    if (Writer_Count == 0) {
        V(s4); // 允许新的读者进入
    }
    V(s3);
    return 0;
}

// 写者优先
void WP()
{
    s1 = C("sig1");
    s2 = C("sig2");
    s3 = C("sig3");
    s4 = C("sig4");
    for (int i = 0; i < c; ++i) {
        if (threads[i].type == 'W') {
            hThread[i] = CT(Writer, &threads[i]);
        }
        else {
            hThread[i] = CT(Reader, &threads[i]);
        }
    }
    PM(c, hThread); //等待所有线程结束
}

int main()
{
    int res = Read_TInfo();
    if (!res) {
        return -1;
    }
    WP();
    for (int i = 0; i < c; ++i) {
        CloseHandle(hThread[i]);
    }
    CloseHandle(s1);
    CloseHandle(s2);
    CloseHandle(s3);
    CloseHandle(s4);
    return 0;
}

成品程序

https://files.cnblogs.com/files/plain8/c.zip?t=1725807121&download=true