读者写者问题 代码

最新推荐文章于 2024-10-09 06:00:00 发布
最新推荐文章于 2024-10-09 06:00:00 发布
阅读量2.9k 收藏 22
点赞数 2
分类专栏： 操作系统
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Puppet__/article/details/85061933
版权 
#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <windows.h>
#include <io.h>
#include <conio.h>
#include  <stdlib.h>
#include <fstream>
using namespace std;

#define READER 'R'  //读者
#define WRITER 'W'  //写者
#define DELAY_TIME 700  //最基本的延迟时间，其他都为他的倍数
#define MAX_THREAD_NUM 64 //最大线程数
int readercount = 0; //读者数量
int writercount = 0; //写者数量
//临界区
CRITICAL_SECTION RP_Write;
CRITICAL_SECTION WP_Write;
CRITICAL_SECTION WP_Read;
//线程结构体
struct Thread{
    int serial;  //线程序号
    char entity;   //判断是读者线程还是写者线程
    double delay;   //线程延迟
    double persist; //线程写操作持续时间
};
//读者优先 读者进程
void RP_ReaderThread(void *p){
    //互斥变量
    HANDLE h_Mutex;
    h_Mutex = OpenMutex(MUTEX_ALL_ACCESS,false,"mutex");
    DWORD m_delay = (DWORD)(((Thread*)(p))->delay*DELAY_TIME); //延迟时间
    DWORD m_persist = (DWORD)(((Thread*)(p))->persist*DELAY_TIME);  //读文件持续时间 用来模拟线程活动
    int m_serial = ((Thread*)(p))->serial; //线程号
    Sleep(m_delay);
    cout<<"读者线程 "<<m_serial<<" 发送读请求"<<endl;

    WaitForSingleObject(h_Mutex,-1);//修改互斥信号量

    readercount++;//读者增加
    if(readercount==1){
        //第一个读者等待资源
        EnterCriticalSection(&RP_Write);
    }
    ReleaseMutex(h_Mutex);
    //读文件
    cout<<"读者线程 "<<m_serial<<" 开始读文件。"<<endl;
    Sleep(m_persist);
    //退出线程
    cout<<"读者线程 "<<m_serial<<" 已读完文件。"<<endl;

    //改变互斥信号量
    WaitForSingleObject(h_Mutex,-1);

    readercount--;
    if(readercount==0){
        //如果所有读者读完，唤醒写者
        LeaveCriticalSection(&RP_Write);
    }
    ReleaseMutex(h_Mutex);//释放信号量
}
//读者优先 写者进程
void RP_WriterThread(void *p){
    DWORD m_delay= (((Thread*)(p))->delay*DELAY_TIME);; //延迟时间
    DWORD m_persist= (((Thread*)(p))->persist*DELAY_TIME);;  //读文件持续时间 用来模拟线程活动
    int m_serial=((Thread*)(p))->serial;; //线程号
    Sleep(m_delay);
    cout<<"写者线程 "<<m_serial<<" 发送写请求。"<<endl;
    //等待资源分配给自己
    EnterCriticalSection(&RP_Write);

    cout<<"写者线程 "<<m_serial<<" 开始写文件。"<<endl;
    Sleep(m_persist);
    cout<<"写者线程 "<<m_serial<<" 已写完文件。"<<endl;
    LeaveCriticalSection(&RP_Write);//释放资源
}
//读者优先处理函数
void ReaderPriority(char *file){
    DWORD n_thread=0; //线程数目
    DWORD thread_ID; //线程ID

    //信号量
    HANDLE h_Mutex;
    h_Mutex=CreateMutex(NULL,false,"mutex");
    //存取线程的数组
    HANDLE h_Thread[MAX_THREAD_NUM];
    Thread threads[MAX_THREAD_NUM];

    readercount = 0;//初始化读者数量
    InitializeCriticalSection(&RP_Write);//初始化临界区
    //打开文件
    ifstream inFile;
    inFile.open(file);
    cout<<"读者优先:"<<endl;
    cout<<endl;
    //获取文件内容
    while(inFile){
        inFile>>threads[n_thread].serial;
        inFile>>threads[n_thread].entity;
        inFile>>threads[n_thread].delay;
        inFile>>threads[n_thread++].persist;
        inFile.get();
    }
    for(int i=0;i<(int)(n_thread);i++){
        if(threads[i].entity==READER||threads[i].entity=='r')
        {
            //创建读者线程
            h_Thread[i]=CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)(RP_ReaderThread),&threads[i],0,&thread_ID);
        }
        else
            //创建写者线程
            h_Thread[i]=CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)(RP_WriterThread),&threads[i],0,&thread_ID);
    }
    //等待所有线程结束
    WaitForMultipleObjects(n_thread,h_Thread,true,-1);
    cout<<"所有的读者和写者完成各自操作。"<<endl;
}

//写者优先 读者进程
void WP_ReaderThread(void *p)
{
    //互斥变量
    HANDLE h_Mutex1;
    h_Mutex1 = OpenMutex(MUTEX_ALL_ACCESS,false,"mutex1");
    HANDLE h_Mutex2;  //互斥信号量 保证对readercount的访问和修改互斥
    h_Mutex2 = OpenMutex(MUTEX_ALL_ACCESS,false,"mutex2");
    DWORD m_delay = (DWORD)(((Thread*)(p))->delay*DELAY_TIME);
    DWORD m_persist = (DWORD)(((Thread*)(p))->persist*DELAY_TIME);
    int m_serial = ((Thread*)(p))->serial;
    Sleep(m_delay);//延迟等待
    cout<<"读者线程 "<<m_serial<<" 发送读请求"<<endl;

    WaitForSingleObject(h_Mutex1,-1);

    //读者进入临界区
    EnterCriticalSection(&WP_Read);
    WaitForSingleObject(h_Mutex2,-1);
    readercount++;//读者的数目增加
    if(readercount==1){
        //第一个读者等待资源，等待读者写完
        EnterCriticalSection(&WP_Write);
    }
    ReleaseMutex(h_Mutex2); //释放信号量
    //使其他读者进入
    LeaveCriticalSection(&WP_Read);
    ReleaseMutex(h_Mutex1);
    //读文件
    cout<<"读者线程 "<<m_serial<<" 开始读文件。"<<endl;
    Sleep(m_persist);
    //退出线程
    cout<<"读者线程 "<<m_serial<<" 已读完文件。"<<endl;
    //修改互斥信号量
    WaitForSingleObject(h_Mutex2,-1);

    readercount--;
    if(readercount==0){
        //如果所有读者读完，唤醒写者
        LeaveCriticalSection(&WP_Write);
    }
    ReleaseMutex(h_Mutex2);//释放信号量
}
//写者优先 写者进程
void WP_WriterThread(void *p){
    DWORD m_delay;
    DWORD m_persist;
    int m_serial;
    //互斥信号量
    HANDLE h_Mutex3;
    h_Mutex3 = OpenMutex(MUTEX_ALL_ACCESS,false,"mutex3");

    //从参数中获取信息
    m_serial=((Thread*)(p))->serial;
    m_delay = (((Thread*)(p))->delay*DELAY_TIME);
    m_persist = (((Thread*)(p))->persist*DELAY_TIME);
    Sleep(m_delay);
    cout<<"写者线程 "<<m_serial<<" 发送写请求。"<<endl;
    WaitForSingleObject(h_Mutex3,-1);//修改互斥信号量
    writercount++;//写者数目增加
    if(writercount==1){
        //第一个写者申请并等待资源
        EnterCriticalSection(&WP_Read);
    }
    ReleaseMutex(h_Mutex3);//释放信号量
    EnterCriticalSection(&WP_Write); //等待资源分配给自己

    cout<<"写者线程 "<<m_serial<<" 开始写文件。"<<endl;
    Sleep(m_persist);
    cout<<"写者线程 "<<m_serial<<" 已写完文件。"<<endl;
    //唤醒其他等待的写者
    LeaveCriticalSection(&WP_Write);
    WaitForSingleObject(h_Mutex3,-1);//修改互斥信号量
    writercount--;
    if(writercount==0){
        //写者数目为0，唤醒读者
        LeaveCriticalSection(&WP_Read);
    }
    ReleaseMutex(h_Mutex3);
}
//写者优先处理函数
void WriterPriority(char *file){
    DWORD n_thread=0; //线程数目
    DWORD thread_ID;//线程ID
    //创建相应临界区
    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];
    Thread threads[MAX_THREAD_NUM];
    //初始化计数器和临界区
    readercount = 0;
    writercount = 0;
    InitializeCriticalSection(&WP_Write);
    InitializeCriticalSection(&WP_Read);
    //打开文件
    ifstream inFile;
    inFile.open(file);
    cout<<"写者优先:"<<endl;
    cout<<endl;
    //获取文件内容
    while(inFile){
        inFile>>threads[n_thread].serial;
        inFile>>threads[n_thread].entity;
        inFile>>threads[n_thread].delay;
        inFile>>threads[n_thread++].persist;
        inFile.get();
    }
    for(int i=0;i<(int)(n_thread);i++){
        if(threads[i].entity==READER||threads[i].entity=='r')
        {
            //创建读者线程
            h_Thread[i]=CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)(RP_ReaderThread),&threads[i],0,&thread_ID);
        }
        else
            //创建写者线程
            h_Thread[i]=CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)(RP_WriterThread),&threads[i],0,&thread_ID);
    }
     WaitForMultipleObjects(n_thread,h_Thread,true,-1);
    cout<<"所有的读者和写者完成各自操作。"<<endl;
}
int main(){
    int num;
    int cnt = 0;
    while(1){
        cout<<"************************************"<<endl;
        cout<<endl;
        cout<<"|             1.读者优先            |"<<endl;
        cout<<"|             2.写者优先            |"<<endl;
        cout<<"|             3.退出程序            |"<<endl;
        cout<<endl;
        cout<<"************************************"<<endl;
start:
        cout<<"请输入你所要进行的选择："<<endl;
        cin>>num;
        if(num<1||num>3)
        {
            cout<<"输入无效，请重新输入"<<endl;
            goto start;
        }
        else if(num==1){
            ReaderPriority("thread.txt");
        }
        else if(num==2){
            WriterPriority("thread.txt");
        }
        else if(num==3)
        {
            exit(0);
        }
        system("pause");
        system("cls");
    }
    system("pause");
    return 0;
}

thread中的内容为

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

6 W 3 5
7 W 16 5
8 R 5 2 
9 W 6 5
10 R 4 3
11 R 17 7

Puppet__
关注
专栏目录
OS: 读者写者问题(写者优先+LINUX+多线程+互斥量+代码)
yaozhiyi的专栏
05-15 1万+
一. 引子 最近想自己写个简单的 WEB SERVER ，为了先练练手，熟悉下在LINUX系统使用基本的进程、线程、互斥等，就拿以前学过的 OS 问题开开刀啦。记得当年学读者写者问题，尤其是写者优先的时候，那是真心纠结啊。刚才还觉得理解了，过一会儿又糊涂了。现在重新再看，还是容易纠结。没办法，用得少。我把读者优先和写者优先都实现了一下。选择性重看了小部分《unix高程》使用了多线程+互斥量实现。
读者与写者问题（源代码+示例）
05-14
读者优先-读者线程，读者优先-写者线程，读者优先处理函数，写者优先-读者线程，写者优先-写者线程，写者优先处理函数...
读者与写者问题（VC源代码）
05-14
读者优先---读者线程，读者优先---写者线程，读者优先处理函数...
查缺补漏----读者写者问题
最新发布
weixin_69884785的博客
10-09 472
查缺补漏----读者写者问题 1.同步问题 2.读者写者 3.综合同步互斥问题（难）
读者写者问题（linux）实现代码
01-02
教材中对读者写者问题算法均有描述，但这个算法在不断地有读者流的情况下，写者会被阻塞。编写一个写者优先解决读者写者问题的程序，其中读者和写者均是多个进程，用信号量作为同步互斥机制。
读者写者问题代码 内核 操作系统
03-10
读者写者问题是一种经典的多线程同步问题，它在操作系统设计和并发编程中占有重要地位。这个问题涉及到多个读者和一个写者共享同一数据资源时如何有效地实现互斥访问。在这个问题中，读者不会改变数据，而写者会修改...
通过研究经典的进程同步问题，采用“读写平等”的策略，用信号量 和 PV 操作实现对读者/写者问题的并发控制
04-21
### 通过研究经典的进程同步问题，采用“读写平等”的策略，用信号量和PV操作实现对读者/写者问题的并发控制 #### 一、背景与目标 本设计旨在通过对经典进程同步问题的研究，利用信号量和PV操作来解决读者/写者...
操作系统读者写者问题源代码
06-28
windows内核实验教程 读者写者源代码
读者写者问题_C
12-23
printf("\t\t*-----------读者写者问题------------*\n"); printf("\t\t* 1:读者优先算法 *\n"); printf("\t\t* 2:先到先服务算法 *\n"); printf("\t\t* 3:写者优先算法 *\n"); printf("\t\t* 4:退出 *\n...
读者-写者问题代码（带注释）个人学习笔记
Loveless_L的博客
03-27 875
个人学习操作系统过程中对于“读者-写者问题”的一些基础的学习理解。
读者写者问题java 代码
12-31
自己编写的读者写者问题java 代码，功能上有点小问题，请谨慎下载！
读者-写者问题C++程序
04-24
规则：多个读者和多个写者共同操作一个文件，当有一个写者在进行写操作时其他读者或写者都不能操作该文件，当有一个读者在进行读操作时，允许其他读者读，但不允许其他写者写。读者和写者都是每隔5秒操作一次，每次操作时间都是3秒。(此例为3个读者，2个写者)
读者-写者问题
SpadgerZ的博客
11-05 2万+
读者写者是一个非常著名的同步问题。读者写者问题描述非常简单，有一个写者很多读者，多个读者可以同时读文件，但写者在写文件时不允许有读者在读文件，同样有读者在读文件时写者也不去能写文件。用图来表示的话 恩，就是这样 问题描述 有读者和写者两组并发进程，共享一个文件，当两个或以上的读进程同时访问共享数据时不会产生副作用，但若某个写进程和其他进程（读进程或写进程）同时访问共享数据时则可能
进程同步的经典问题1——读者写者问题（写者优先与公平竞争）
热门推荐
勇者无敌
08-13 2万+
出处：http://dantvt.spaces.live.com读者-写者问题 写者优先与公平竞争多进程对共享资源互斥访问及进程同步的经典问题 设有一文件F，多个并发读进程和写进程都要访问，要求：(1)读写互斥(2)写写互斥(3)允许多个读进程同时访问采用记录型信号量机制解决 较常见的写法：semaphore fmutex=1, rdcn
操作系统读者写者问题代码实现
Blank_Tt的博客
05-14 1万+
问题分析： 读者优先: 读者进程执行: 无其他读者写者, 直接执行 有写者等, 但其他读者在读, 直接读 有写者写, 等待 写者进程执行: 无其他读写者, 直接执行 有其他读写者, 等待 写者优先: 读者进程执行: 如果此时没有写者等待, 直接执行 如果有写者等待, 那么等待 写者进程执行: 如果没有其他写者, 那么执行 如果有其他读写者, ...
读者写者问题代码linux,读者写者问题 代码
weixin_34502341的博客
05-12 475
#include using namespace std;#define READER 'R' //读者#define WRITER 'W' //写者#define DELAY_TIME 700 //最基本的延迟时间，其他都为他的倍数#define MAX_THREAD_NUM 64 //最大线程数int readercount = 0; //读者数量int writercount = 0;...
c语言读者写者问题代码
06-01
以下是C语言实现读者写者问题的代码，使用信号量机制： 引用:使用POSIX信号量机制解决读者-写者问题C语言实现，读者和写者进程数量可设置。[^1] ```c #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <pthread.h> #include <fcntl.h> #include <semaphore.h> #include <sys/mman.h> #define FILE_MODE (S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH) // 全局变量 static sem_t *r_lock; // 读者锁 static sem_t *rw_lock; // 写者锁 static int *read_cnt; // 读者数量计数器 static int *data; // 共享数据区 // 读者线程 void *reader(void *arg) { int id = *(int *)arg; while (1) { // 读者锁加锁 sem_wait(r_lock); (*read_cnt)++; if (*read_cnt == 1) { sem_wait(rw_lock); } // 读者锁解锁 sem_post(r_lock); // 读取数据 printf("Reader %d is reading data: %d\n", id, *data); // 读者锁加锁 sem_wait(r_lock); (*read_cnt)--; if (*read_cnt == 0) { sem_post(rw_lock); } // 读者锁解锁 sem_post(r_lock); // 等待一段时间 sleep(rand() % 3 + 1); } return NULL; } // 写者线程 void *writer(void *arg) { int id = *(int *)arg; while (1) { // 写者锁加锁 sem_wait(rw_lock); // 写入数据 (*data)++; printf("Writer %d is writing data: %d\n", id, *data); // 写者锁解锁 sem_post(rw_lock); // 等待一段时间 sleep(rand() % 3 + 1); } return NULL; } int main(int argc, char *argv[]) { // 获取参数 if (argc != 3) { printf("usage: %s <reader_num> <writer_num>\n", argv); exit(1); } int reader_num = atoi(argv); int writer_num = atoi(argv); // 创建共享内存 int fd = shm_open("/shm", O_CREAT | O_RDWR, FILE_MODE); ftruncate(fd, sizeof(sem_t) * 2 + sizeof(int) * 2); r_lock = mmap(NULL, sizeof(sem_t), PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); rw_lock = mmap(NULL, sizeof(sem_t), PROT_READ | PROT_WRITE, MAP_SHARED, fd, sizeof(sem_t)); read_cnt = mmap(NULL, sizeof(int), PROT_READ | PROT_WRITE, MAP_SHARED, fd, sizeof(sem_t) * 2); data = mmap(NULL, sizeof(int), PROT_READ | PROT_WRITE, MAP_SHARED, fd, sizeof(sem_t) * 2 + sizeof(int)); // 初始化信号量 sem_init(r_lock, 1, 1); sem_init(rw_lock, 1, 1); // 创建读者线程 pthread_t tid[reader_num + writer_num]; int index = 0; for (int i = 0; i < reader_num; i++) { int *id = malloc(sizeof(int)); *id = ++index; pthread_create(&tid[i], NULL, reader, id); } // 创建写者线程 for (int i = 0; i < writer_num; i++) { int *id = malloc(sizeof(int)); *id = ++index; pthread_create(&tid[reader_num + i], NULL, writer, id); } // 等待线程结束 for (int i = 0; i < reader_num + writer_num; i++) { pthread_join(tid[i], NULL); } // 销毁信号量 sem_destroy(r_lock); sem_destroy(rw_lock); // 删除共享内存 munmap(r_lock, sizeof(sem_t)); munmap(rw_lock, sizeof(sem_t)); munmap(read_cnt, sizeof(int)); munmap(data, sizeof(int)); shm_unlink("/shm"); return 0; } ``` 引用:使用System V信号量机制解决读者-写者问题C语言实现，读者和写者进程数量可设置。 ```c #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <pthread.h> #include <sys/sem.h> #include <sys/ipc.h> #include <sys/shm.h> #include <sys/types.h> // 定义信号量操作 static struct sembuf sem_r_lock = { {0, 0, SEM_UNDO}, {0, 1, SEM_UNDO}, }; static struct sembuf sem_r_unlock = { {0, -1, SEM_UNDO}, }; static struct sembuf sem_rw_lock = { {1, 0, SEM_UNDO}, {0, 0, SEM_UNDO}, }; static struct sembuf sem_rw_unlock = { {1, -1, SEM_UNDO}, }; // 全局变量 static int sem_id; // 信号量ID static int *read_cnt; // 读者数量计数器 static int *data; // 共享数据区 // 读者线程 void *reader(void *arg) { int id = *(int *)arg; while (1) { // 读者锁加锁 semop(sem_id, sem_r_lock, 2); (*read_cnt)++; if (*read_cnt == 1) { semop(sem_id, sem_rw_lock, 2); } // 读者锁解锁 semop(sem_id, sem_r_unlock, 1); // 读取数据 printf("Reader %d is reading data: %d\n", id, *data); // 读者锁加锁 semop(sem_id, sem_r_lock, 2); (*read_cnt)--; if (*read_cnt == 0) { semop(sem_id, sem_rw_unlock, 1); } // 读者锁解锁 semop(sem_id, sem_r_unlock, 1); // 等待一段时间 sleep(rand() % 3 + 1); } return NULL; } // 写者线程 void *writer(void *arg) { int id = *(int *)arg; while (1) { // 写者锁加锁 semop(sem_id, sem_rw_lock, 2); // 写入数据 (*data)++; printf("Writer %d is writing data: %d\n", id, *data); // 写者锁解锁 semop(sem_id, sem_rw_unlock, 1); // 等待一段时间 sleep(rand() % 3 + 1); } return NULL; } int main(int argc, char *argv[]) { // 获取参数 if (argc != 3) { printf("usage: %s <reader_num> <writer_num>\n", argv); exit(1); } int reader_num = atoi(argv); int writer_num = atoi(argv); // 创建共享内存 int shmid = shmget(IPC_PRIVATE, sizeof(int) * 2, IPC_CREAT | 0666); read_cnt = (int *)shmat(shmid, 0, 0); data = read_cnt + 1; // 初始化共享内存 *read_cnt = 0; *data = 0; // 创建信号量 sem_id = semget(IPC_PRIVATE, 2, IPC_CREAT | 0666); semctl(sem_id, 0, SETVAL, 1); semctl(sem_id, 1, SETVAL, 1); // 创建读者线程 pthread_t tid[reader_num + writer_num]; int index = 0; for (int i = 0; i < reader_num; i++) { int *id = malloc(sizeof(int)); *id = ++index; pthread_create(&tid[i], NULL, reader, id); } // 创建写者线程 for (int i = 0; i < writer_num; i++) { int *id = malloc(sizeof(int)); *id = ++index; pthread_create(&tid[reader_num + i], NULL, writer, id); } // 等待线程结束 for (int i = 0; i < reader_num + writer_num; i++) { pthread_join(tid[i], NULL); } // 删除信号量 semctl(sem_id, 0, IPC_RMID, 0); // 删除共享内存 shmdt(read_cnt); shmctl(shmid, IPC_RMID, 0); return 0; } ```
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值