#include <stdio.h>
#include <Windows.h>
#include <process.h>
#include<stdbool.h>

void Input(void*);
void Output(void*);

/*定义输出机数量与需要输出的PC机数量*/
#define Writer_COUNT 8//  PC机数量(写者)——向输出井输出数据
#define Reader_COUNT 3//输出机数量(读者)——从输出井取出数据输出
/* 信号量句柄 */
HANDLE write;//进程优先互斥
HANDLE mutex;//临界资源互斥
HANDLE RCsignal;//读者数Rcount修改互斥
HANDLE WCsignal;//写者数Wcount修改互斥
/* 读写进程的数量 */
int reader_count = 0;
int writer_count = 0;

/* 主线程 */
int main()
{
    bool flag = true;
    /*开辟共享内存空间*/

    /* 创建信号量 */
    write = CreateSemaphore(NULL, 1, 1, NULL);
    mutex = CreateSemaphore(NULL, 1, 1, NULL);
    RCsignal = CreateSemaphore(NULL, 1, 1, NULL);
    WCsignal = CreateSemaphore(NULL, 1, 1, NULL);

    HANDLE hThreads[Writer_COUNT + Reader_COUNT]; //各线程的 handle
    DWORD writerID[Writer_COUNT]; //写者线程的标识符
    DWORD readerID[Reader_COUNT]; //读者线程的标识符
    /* 创建线程 */
    srand(time(0));

    for (int i = 0; i < Writer_COUNT + Reader_COUNT; i++)
    {
        int ran = rand() % 10;
        if ((ran < 5) && (writer_count < Writer_COUNT))//Writer
        {
            hThreads[i] = (HANDLE)_beginthread(Input, 0, NULL);
            if (hThreads[i] == NULL) return -1;
        }
        else if ((ran >= 5) && (reader_count < Reader_COUNT))//Reader
        {
            hThreads[i] = (HANDLE)_beginthread(Output, 0, NULL);
            if (hThreads[i] == NULL) return -1;
        }
        printf("运行了%d个writer线程, %d个reader线程======\n", writer_count, reader_count);
        Sleep(500);//等待500ms
    }
    //while (flag == true)
    //{
    //    if (getchar())  //按回车后终止程序运行
    //    {
    //        flag = false;
    //    }
    //}
    //WaitForSingleObject(, INFINITE);
    Sleep(5000);
    CloseHandle(write);
    CloseHandle(mutex);
    CloseHandle(RCsignal);
    CloseHandle(WCsignal);
    printf("主线程结束");
    return 0;
}


/* PC机线程，向输出井中写入数据——写者 */
void Input(void* arg)
{
        WaitForSingleObject(WCsignal, INFINITE);
        if (writer_count == 0) {
            WaitForSingleObject(write, INFINITE);
        }
        writer_count++;
        ReleaseSemaphore(WCsignal, 1, NULL);
        WaitForSingleObject(mutex, INFINITE);
        printf("%d号PC机正在写入数据\n", GetCurrentThreadId());
        Sleep(3000);
        ReleaseSemaphore(mutex, 1, NULL);
        WaitForSingleObject(WCsignal, INFINITE);
        writer_count--;
        if (writer_count == 0) {
            ReleaseSemaphore(write, 1, NULL);
        }
        ReleaseSemaphore(WCsignal, 1, NULL);
        return;
}


/* 输出机线程，从输出井取出数据并展示在屏幕——读者 */
void Output(void* arg)
{
        WaitForSingleObject(write, INFINITE);//防止其他进程在写
        WaitForSingleObject(RCsignal, INFINITE);//互斥修改reader_count
        if (reader_count == 0) {
            WaitForSingleObject(mutex, INFINITE);//当目前没有读进程，需要设置读与写互斥访问
        }
        reader_count++;
        ReleaseSemaphore(RCsignal, 1, NULL);
        ReleaseSemaphore(write,  1, NULL);
        //此处进行相关的读取操作
        printf("%d 号进程正在进行读操作...\n", GetCurrentThreadId());
        Sleep(3000);
        WaitForSingleObject(RCsignal, INFINITE);
        reader_count--;
        if (reader_count == 0) {
            ReleaseSemaphore(mutex, 1, NULL);
        }
        ReleaseSemaphore(RCsignal, 1, NULL);
        return;
}

本来做spooling技术——OS课设，卡了很久很久，一直想着要去调用API去创建进程实现spooling但是说实话对于底层的API都不熟悉，确实写的很难受，现在推翻重来了，上面的代码算是记笔记了。