读者写者问题模拟实现-读者优先 写者优先

已于 2022-10-12 16:11:17 修改
阅读量2.1k 收藏 58
点赞数 7
分类专栏： 学习 大学课程 文章标签： c++ windows
于 2022-06-10 23:21:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Fandos/article/details/125229423
版权

主要特点：

  • 输出有纵坐标，同一个线程的请求，开始，结束的表示符在同一列上，不同的不在同一列
  • 输出控制台加锁，防止输出的时候被别的线程打断，导致错位
  • 四段锁实现读者写者模拟问题，使用了两种库函数锁
  • 线程初始化自动获取存放在程序里面的有效线程个数

可以改进的方向：

  • 这个线程的初始化是在程序里面写死的，没有在控制台里面输入，我主要是感觉每次都输入挺麻烦的，而且数据太少，也不能体现读者写者优先的效果，数据太少有片面性，一开始改这个程序的时候，就是数据太少没看出来写者优先的锁加的不对。所以可以在保留数据加载的情况下，通过控制台可以改变数据或者新增数据，这样可以考虑预先设定好的数据是在程序里面还是说在文本文件里面。
  • 虽然使用了纵坐标输出，感觉起来更能明显的看出来运行顺序，但实际上，如果是两个线程在同时发起请求，这还是会不再一行上（同一行应该是一个时间），这个要编程实现呢就可能比较麻烦了，应该需要在输出的时候交给另外一个线程进行控制，这样可以在一行上输出两小段或更多段文字。我就这一个思路，供后来者参考吧。
  • 再就是，毕竟是写者优先和读者优先算法的模拟实现，比较一下两个算法的时间复杂度应该还是挺有意义的，这个也可以试一下，同样的数据，运行时间有什么不一样，什么样的数据在读者优先下总体性能会更高之类的，写者优先也同理。
  • 上面说了总体性能，那每个线程的执行时间/(结束时间-开始时间)这个参数呢，这也是一个很重要的进程调度参数。
  • 这里只实现了读者写者优先，还有一个经典算法是公平竞争。
  • 还有就是优先级抢占的问题，有没有紧急任务要紧急占用线程使用权。

实际的操作系统实现需要考虑很多内容，这是我在做这次课设考虑到的一些方面，我在原先的代码上改进了一部分，但没能将上述问题都进行实现，特以记录。如果有大佬把上面的问题实现一部分或者全部，希望能够在评论区留言，让我拜读一下代码。

上代码，运行环境是DEV-C++ 5.9.2。

#include <windows.h>
#include <conio.h>
#include <stdlib.h>
#include <fstream>
#include <io.h>
#include <string.h>
#include <stdio.h>
using namespace std;
#define READER 'R'
#define WRITER 'W'
#define MAX_THREAD_NUM 32  //最大线程数目
CRITICAL_SECTION RP_Write; //临界区
CRITICAL_SECTION WP_Write; //写者优先临界区 
CRITICAL_SECTION PR_right; //写者优先控制读者锁 
CRITICAL_SECTION P_OUT;    //输出临界区

#define INTE_PER_SEC 100  //每秒时钟中断数目
#define MAX_FILE_NUM 32   //最大数据文件数目
#define MAX_STR_LEN 32    //字符串长度
int readcount=0;          //读者数目
int writecount=0;         //写者数目
struct ThreadInfo
{	int serial;           //线程序号
	char entity;          //线程类别
	double delay;         //线程开始时间
	double persist;       //线程读写持续时间
};
//创建 MAX_THREAD_NUM个线程数组，赋有初值不为0的是有效线程 
ThreadInfo  thread_info[MAX_THREAD_NUM]={
{1,'R',2,4},
{2,'W',3,4},
{3,'R',4,6},
{4,'R',6,4},
{5,'W',7,2},
{6,'W',8,6},
{7,'R',9,5},
{8,'R',10,3},
{9,'R',11,4},
{10,'W',12,4}
};
//读者优先处理函数
void ReaderPriority();   
void RP_ReaderThread(void *p);
void RP_WriterThread(void *p);
//写者优先处理函数
void WriterPriority();  
void WP_ReaderThread(void *p);
void WP_WriterThread(void *p);
//控制台输出处理函数，互斥地输出，防止输出过程被打断 
//用不同函数名表明做的是什么操作 
void Reader_request(int m_ID);
void Reader_start(int m_ID); 
void Reader_finish(int m_ID);
void Writer_request(int m_ID);
void Writer_start(int m_ID); 
void Writer_finish(int m_ID);
//获取有效的线程数目 
int sizeof_m();
int tread_num = sizeof_m();

int main()
{
	//输出一下目前待运行的线程的详细信息 
    printf("序号  读者或写者    开始时间    持续时间\n");  
	for(int i=0;i<tread_num;i++)
	{	printf(" %d\t  %c\t    %f\t%f\n",
        thread_info[i].serial,thread_info[i].entity,thread_info[i].delay,thread_info[i].persist);
    }
    InitializeCriticalSection(&P_OUT);     //初始化输出临界区
	//分别运行读者写者优先算法，方便比较 
	ReaderPriority();//读者优先
    WriterPriority();//写者优先
    
	//退出程序 
	system("pause");
	return 0;
}
//读者优先处理函数
void ReaderPriority()
{
	DWORD n_thread=tread_num;   //线程数目
	DWORD thread_ID;            //线程ID
	DWORD wait_for_all;         //等待所有线程结束
	HANDLE rmutex;	            //使读者互斥访问readcount
	//创建信号量remutex，不设定安全相关属性，不占有互斥量 
	rmutex=CreateMutex(NULL,FALSE,"mutex_for_readcount"); 
	HANDLE h_Thread[MAX_THREAD_NUM];
	readcount=0;                //初始化readcount
	InitializeCriticalSection(&RP_Write);  //初始化读者临界区
	
	printf("读者优先:（纵坐标为执行顺序）\n");
	for (int i=0;i<(int)(n_thread);i++)
	{
		if (thread_info[i].entity==READER || thread_info[i].entity=='r')
			//如果是读者线程，创建读者线程
			//不设置安全属性，分配0字节线程堆栈，指向读者线程函数地址
			//给读者线程的参数，立即执行当前线程，把新创建的线程编号给thread_ID
			h_Thread[i]=CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)(RP_ReaderThread),&thread_info[i],0,&thread_ID);
		else
			//如果不是，创建写者线程
			//不设置安全属性，分配0字节线程堆栈，指向写者线程函数地址
			//给读者线程的参数，立即执行当前线程，把新创建的线程编号给thread_ID
			h_Thread[i]=CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)(RP_WriterThread),&thread_info[i],0,&thread_ID);
	}
	//等待所有线程结束
	wait_for_all=WaitForMultipleObjects(n_thread,h_Thread,TRUE,-1);
	printf("所有操作完成\n\n");
}
//读者优先-----读者线程
void RP_ReaderThread(void *p)
{	
	int m_ID;           //线程序号
	DWORD m_delay;      //准备延迟时间
	DWORD m_persist;    //读文件持续时间
	m_ID=((ThreadInfo *)(p))->serial;  //获取线程序号 
	m_delay=(DWORD)(((ThreadInfo *)(p))->delay*INTE_PER_SEC);     //设置准备等待时间 
	m_persist=(DWORD)(((ThreadInfo *)(p))->persist*INTE_PER_SEC); //设置读持续时间 

    HANDLE rmutex;      //使读者互斥访问readcount
	rmutex=OpenMutex(MUTEX_ALL_ACCESS,FALSE,"mutex_for_readcount"); //开启rmutex 
	DWORD wait_for_mutex;  //等待互斥变量所有权

	Sleep(m_delay);        //准备等待延迟 
	Reader_request(m_ID);  //读者请求输出 
	
	//P(rmutex)
	wait_for_mutex=WaitForSingleObject(rmutex,-1); 
	readcount++;           //读者数目加1
	if (readcount==1)
		//读进程与写进程互斥，如果这是第一个读者，进入临界区，开始执行 P(RP_Write);
		EnterCriticalSection(&RP_Write);  
	ReleaseMutex(rmutex); 
	//V（rmutex）
	
	Reader_start(m_ID);    //读者正在读输出 
	Sleep(m_persist);      //读持续延迟 
	Reader_finish(m_ID);   //读者完成读输出 
	
	//P(rmutex)
	wait_for_mutex=WaitForSingleObject(rmutex,-1);  
	readcount--;           //读者数目减1
	if (readcount==0)
		//读进程与写进程互斥，如果这是最后一个读者，则其释放临界区V(RP_Write);
		LeaveCriticalSection(&RP_Write); 
	ReleaseMutex(rmutex); 
	//V(rmutex)
}
//读者优先-----写者线程
void RP_WriterThread(void *p)
{
	DWORD m_delay;        //延迟时间
	DWORD m_persist;      //读文件持续时间
	int m_ID;             //线程序号
	m_ID=((ThreadInfo *)(p))->serial;  //获取线程序号 
	m_delay=(DWORD)(((ThreadInfo *)(p))->delay*INTE_PER_SEC);     //设置准备等待时间 
	m_persist=(DWORD)(((ThreadInfo *)(p))->persist*INTE_PER_SEC); //设置写持续时间

	Sleep(m_delay);       //准备等待延迟
	Writer_request(m_ID); //写者写请求输出
	 
	//进入临界区  P(RP_Write)
	EnterCriticalSection(&RP_Write);
	Writer_start(m_ID);    //写者开始写输出 
	Sleep(m_persist);      //写持续延迟 
	Writer_finish(m_ID);   //写者写完成输出 
	LeaveCriticalSection(&RP_Write); 
	//退出后，离开临界区 V(RP_Write)
}
//写者优先处理函数
void WriterPriority(){
	DWORD n_thread=tread_num;     //线程数目
	DWORD thread_ID;              //线程ID
	DWORD wait_for_all;           //等待所有线程结束
	HANDLE r_Mutex;               //使读者互斥访问readcount
	HANDLE w_Mutex;               //使写者互斥访问writecount
	HANDLE wp_Mutex;              //给以写者优先权的互斥变量
	r_Mutex=CreateMutex(NULL,FALSE,"mutex_for_readcount");       //读互斥量创建 
	w_Mutex=CreateMutex(NULL,FALSE,"mutex_for_writecount");      //写互斥量创建 
	wp_Mutex=CreateMutex(NULL,FALSE,"mutex_for_writerpriority"); //写优先互斥量创建 
	HANDLE h_Thread[MAX_THREAD_NUM];
	readcount=0;      //初始化readcount
	writecount=0;     //初始化writecount
	InitializeCriticalSection(&WP_Write);  //初始化临界区
	InitializeCriticalSection(&PR_right);  //初始化临界区
	printf("写者优先:（纵坐标为执行顺序）\n");
	for (int i=0;i<(int)(n_thread);i++)
	{
		if (thread_info[i].entity==READER || thread_info[i].entity=='r')
			//如果是读者线程，创建读者线程
			//不设置安全属性，分配0字节线程堆栈，指向读者线程函数地址
			//给读者线程的参数，立即执行当前线程，把新创建的线程编号给thread_ID
            h_Thread[i]=CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)(WP_ReaderThread),&thread_info[i],0,&thread_ID);
		else
			//如果不是，创建写者线程
			//不设置安全属性，分配0字节线程堆栈，指向写者线程函数地址
			//给读者线程的参数，立即执行当前线程，把新创建的线程编号给thread_ID
            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("所有操作完成\n");
}

//写者优先-----读者线程
void WP_ReaderThread(void *p){	
	DWORD m_delay;        //准备延迟时间
	DWORD m_persist;      //读文件持续时间
	int m_ID;             //线程序号
	m_ID=((ThreadInfo *)(p))->serial;                               //获取线程序号 
	m_delay=(DWORD)(((ThreadInfo *)(p))->delay*INTE_PER_SEC);       //设置准备等待时间  
	m_persist=(DWORD)(((ThreadInfo *)(p))->persist*INTE_PER_SEC);   //设置读持续时间 

	HANDLE rmutex;       //使读者互斥访问readcount    
	rmutex=OpenMutex(MUTEX_ALL_ACCESS,FALSE,"mutex_for_readcount"); //开启rmutex
	DWORD wait_for_rmutex;   //等待互斥变量所有权
	DWORD wait_for_right;  //等待互斥变量所有权

	Sleep(m_delay);       //准备等待延迟	
	Reader_request(m_ID); //读者请求输出 
	
	//P(PR_right)
	EnterCriticalSection(&PR_right); 
	//P(rmutex)
	wait_for_rmutex=WaitForSingleObject(rmutex,-1);   
	if (readcount==0)
		EnterCriticalSection(&WP_Write);   //如果这是第一个读者，写者优先进入临界区 P(WP_Write)
	readcount++;          //读者数目加1
	ReleaseMutex(rmutex);
	//V(rmutex)
	LeaveCriticalSection(&PR_right);  
	//V(PR_right)
	
	Reader_start(m_ID);  //读者正在读输出 
	Sleep(m_persist);    //读持续延迟 
	Reader_finish(m_ID); //读者完成读输出 
	
	//P(rmutex)
	wait_for_rmutex=WaitForSingleObject(rmutex,-1);
	readcount--;         //读者数目减1
	if (readcount==0)
		LeaveCriticalSection(&WP_Write);   //如果读者都退出，写者进入临界区V(WP_Write)
	ReleaseMutex(rmutex);
	//V(rmutex)
}
//写者优先-----写者线程
void WP_WriterThread(void *p){
	DWORD m_delay;         //延迟时间
	DWORD m_persist;       //读文件持续时间
	int m_ID;              //线程序号
	m_ID=((ThreadInfo *)(p))->serial;                              //获取线程序号 
	m_delay=(DWORD)(((ThreadInfo *)(p))->delay*INTE_PER_SEC);      //设置准备等待时间 
	m_persist=(DWORD)(((ThreadInfo *)(p))->persist*INTE_PER_SEC);  //设置读持续时间 

	HANDLE writerm;      //给以写者优先权的互斥变量
	HANDLE wmutex;       //使写者互斥访问writecount
	writerm=OpenMutex(MUTEX_ALL_ACCESS,FALSE,"mutex_for_writerpriority");  //开启writerm
	DWORD wait_for_writerm; //等待互斥变量所有权

	Sleep(m_delay);       //准备等待延迟	
	Writer_request(m_ID); //写者写请求输出 
	
	//P(writerm)
	wait_for_writerm=WaitForSingleObject(writerm,-1); 
	writecount++;         //写者数目加1
	if (writecount==1)
		EnterCriticalSection(&PR_right);     //如果是第一个写者，进入临界区P(PR_right)
	ReleaseMutex(writerm);
	//V(writerm)
	
	//P(WP_Write)
	EnterCriticalSection(&WP_Write);
	Writer_start(m_ID);   //写者写完成输出 
	Sleep(m_persist);     //写持续延迟 
	Writer_finish(m_ID);  //写者写完成输出 
	LeaveCriticalSection(&WP_Write);
	//V(WP_Write)
	
	//P(writerm)
	wait_for_writerm=WaitForSingleObject(writerm,-1); 
	writecount--;         //写者数目减1
	if (writecount==0)
    	LeaveCriticalSection(&PR_right);   //如果是最后一个写者退出，离开临界区V(PR_right)
	ReleaseMutex(writerm);
	//V(writerm)
}
//读者请求输出函数 
void Reader_request(int m_ID)
{
	//P(P_OUT) 输出互斥 
	EnterCriticalSection(&P_OUT);
	for(int i=1;i<m_ID;i++)
	printf("           ");
	printf("读者%d读请求\n",m_ID);
	LeaveCriticalSection(&P_OUT);
	//V(P_OUT)	
}
//读者开始输出函数 
void Reader_start(int m_ID)
{
	//P(P_OUT) 输出互斥 
	EnterCriticalSection(&P_OUT);	
    for(int j=1;j<m_ID;j++)//读文件
	printf("           ");
	printf("读者%d开始读\n",m_ID);
	LeaveCriticalSection(&P_OUT);
	//V(P_OUT) 
}
//读者结束输出函数 
void Reader_finish(int m_ID)
{
	//P(P_OUT) 输出互斥 
	EnterCriticalSection(&P_OUT);
    for(int k=1;k<m_ID;k++)//退出线程
	printf("           ");
	printf("读者%d完成读\n\n",m_ID);
	LeaveCriticalSection(&P_OUT);
	//V(P_OUT)
}
//写者请求输出函数 
void Writer_request(int m_ID)
{
	//P(P_OUT) 输出互斥 
	EnterCriticalSection(&P_OUT);
	for(int i=1;i<m_ID;i++)
	printf("           ");
	printf("写者%d写请求\n",m_ID);
	LeaveCriticalSection(&P_OUT);
	//V(P_OUT)	
}
//写者开始输出函数 
void Writer_start(int m_ID)
{
	//P(P_OUT) 输出互斥 
	EnterCriticalSection(&P_OUT);
    for(int l=1;l<m_ID;l++)	//写文件
	printf("           ");
	printf("写者%d开始写\n",m_ID);
	LeaveCriticalSection(&P_OUT);
	//V(P_OUT)
}
//写者结束输出函数 
void Writer_finish(int m_ID)
{
	//P(P_OUT) 输出互斥 
	EnterCriticalSection(&P_OUT);
    for(int t=1;t<m_ID;t++)	//退出线程
	printf("           ");
	printf("写者%d完成写\n",m_ID);
	LeaveCriticalSection(&P_OUT);
	//V(P_OUT)
}
//获取当前初始化的有效线程个数  
int sizeof_m()
{	
	for(int i=0;i<MAX_THREAD_NUM;i++)
	{
		if(thread_info[i].serial==0)
		return i;
	}
	return MAX_THREAD_NUM;
}

在这里插入图片描述在这里插入图片描述
附上两张我画的流程图：
读者优先：
在这里插入图片描述
写者优先：
在这里插入图片描述

“读者-写者问题”的写者优先算法实现
zoudaokou2006的专栏
03-07 3万+
读者一写者问题是一个用信号量实现的经典进程同步问题。在系统中，一个数据集( 如文件或记录) 被几个并发进程共享，这些线程分两类，一部分只要求进行复操作，称之为“读者”；另一类要求写或修改操作，我们称之为“写者“。一般而言，对一个数据集，为了保证数据的完整性、正确性，允许多个读者进程同时访问，但是不允许一个写者进程同其它任何一个进程（读者或者写者）同时访问，而这类问题就称之为”读者-写者“问题。
读者写者问题的写者优先算法
wwangzai的博客
11-16 9343
读者写者问题的写者优先算法问题描述：写者优先问题分析：需要用到的变量和信号量：算法如下： 问题描述： 有读者(reader)和写者(writer)两组并发进程，共享一个文件，当两个或以上的读进程同时访问共享数据时不会产生副作用，但若某个写进程和其他进程（读进程或写进程）同时访问共享数据时则可能导致数据不一致的错误。 因此要求： ① 允许多个读进程可以同时对文件执行读操作； ② 只允许一个写进程往...
【操作系统】读者-写者问题
最新发布
m0_37806005的博客
05-04 381
 读者-写者问题是并发编程中的一个经典问题，描述了一个场景，其中多个读者和多个写者共享一个资源（如文件或数据库）
C++实现读者写者问题模拟
01-01
用C++实现的读者写者问题，对理解同步互斥问题很有帮助的
模拟生产者-消费者问题和读者-写者问题
振华OPPO的博客世界
03-26 7933
一组生产者进程生产产品给一组消费者进程消费。一个有n个缓冲区的缓冲池，生产者一次向一个缓冲区中投入消息，消费者从一个缓冲区中取得。生产者——消费者问题实际上是相互合作进程关系的一种抽象。该类问题不允许消费者进程到一个空缓冲区中取产品，同时也不允许生产者进程到一个已满且还没被取走的缓冲区中投放产品。 使用一个数组来表示具有n个(0，1，…，n-1)缓冲区的缓冲池。用输入指针in来指示下一个可投放产品的缓冲区，每当生产者进程生产并投放一个产品后，in加1；用一个输出指针out来指示下一个可从中获取产品的缓冲区，
读者写者问题写者优先实现
11-22
在Windows2000环境下，创建一个控制台进程，此进程包含n个线程。用这n个线程来表示n个读者或写者。每个线程按相应测试数据文件（后面介绍）的要求进行读写操作。用信号量机制分别实现读者优先和写者优先问题。 读者-写者问题的读写操作限制（包括读者优先和写者优先） 1） 写-写互斥：不能有两个写者同时进行写操作 2） 读-写互斥：不能同时有一个线程在读，而另一个线程在写。 3） 读-读允许：可以有一个或多个读者在读。 读者优先的附加限制：如果读者申请进行读操作时已有另一个读者正在进行读操作，则该读者可直接开始读操作。 写者优先的附加限制：如果一个读者申请进行读操作时已有另一个写者在等待访问共享资源，则该读者必须等到没有写者处于等待状态后才能开始读操作。 运行结果显示要求：要求在每个线程创建、发出读写申请、开始读写操作和结束读写操作时分别显示一行提示信息，以确定所有处理都遵守相应的读写操作限制。
天津大学计算机科学与技术专业操作系统读者写者问题C++实现
01-27
天津大学计算机科学与技术专业的学生通过C++语言实现了这一问题的解决方案，分别考虑了读者优先和写者优先的情况。 首先，理解读者写者问题是解决并发控制的关键。在读者优先的方案中，系统优先保证尽可能多的读者...
南京大学操作系统实验-模拟读者优先和写者优先问题.zip
06-01
在这个实验中，我们关注的是并发访问共享资源时可能出现的问题，特别是“读者优先”和“写者优先”策略的模拟。这两个概念源自多用户、多任务环境下对共享数据的访问控制，旨在优化系统性能和响应时间。 “读者优先...
读写优先.rar_win32 读写者_任务5--事件对象解决读写者问题
07-14
事件对象解决读写者问题实现P、V操作用Win32提供的同步对象实现P、V操作，并使用它们解决读者-写者问题 利用事件机制模拟多值信号量。
C#模拟读者写者问题
十七楼的幻想
11-09 3010
原本是操作系统的一个上机作业，上课没注意听所以一直都不知道，明天都要交了只好用C#简单写了个，好在.NET强大的FCL提供了读者写者锁类，因此实现起来方便许多，读者写者锁在读者数目多于写者时会显示出比监视器（类似于操作系统中讲到的管程）更好的性能。具体的说，每个读者线程在访问临界资源的时候申请读者锁，访问结束后释放锁，同样，写者线程在访问资源时申请写者锁，访问结束释放锁。如果锁被一个写者线程而不是
读者写者问题的写优先实现
04-26
读者写者问题的写优先实现，操作系统的作业，自己写的，可以实现创建多个读者写者。
C语言模拟读者写者问题
04-14
在Windows2000环境下，创建一个控制台进程，此进程包含n个线程。用这n个线程来表示n个读者或写者。每个线程按相应测试数据文件（后面介绍）的要求进行读写操作。用信号量机制分别实现读者优先和写者优先问题。 读者-写者问题的读写操作限制（包括读者优先和写者优先） 1） 写-写互斥：不能有两个写者同时进行写操作 2） 读-写互斥：不能同时有一个线程在读，而另一个线程在写。 3） 读-读允许：可以有一个或多个读者在读。 读者优先的附加限制：如果读者申请进行读操作时已有另一个读者正在进行读操作，则该读者可直接开始读操作。 写者优先的附加限制：如果一个读者申请进行读操作时已有另一个写者在等待访问共享资源，则该读者必须等到没有写者处于等待状态后才能开始读操作。 运行结果显示要求：要求在每个线程创建、发出读写申请、开始读写操作和结束读写操作时分别显示一行提示信息，以确定所有处理都遵守相应的读写操作限制。
读者写者问题的实现
03-03
这是一个关于操作系统中关于读者写者问题的实现，通过简单易懂的c语言代码实现其功能，既可以让读者读入数据，也可以通过写着写出数据。
操作系统 - C语言实现读者写者问题（写者优先）
热门推荐
lllllyt的博客
05-30 5万+
同步互斥问题 - 读者写者问题之写者优先 问题要求： 读者-写者问题的读写操作限制(仅读者优先或写者优先)： 写-写互斥，即不能有两个写者同时进行写操作。 读-写互斥，即不能同时有一个线程在读，而另一个线程在写。 读-读允许，即可以有一个或多个读者在读。 写者优先的附加限制：如果一个读者申请进行读操作时已有另一写者在等待访问共享资源，则该读者必须等到没有写者处于等待状态后才能开始读操作。...
C++ 多线程学习笔记（6）：读者-写者问题模拟
佚失的诗篇
06-16 2952
文章目录一、介绍说明二、使用的语法现象三、代码四、遇到的问题 一、介绍说明 语言：C++11 题目：读者-写者问题模拟 背景： 2个读者5个写者，操作一个共享的数据区（用一个string字符串代表） 写者和其他写者、读者是互斥的 读者和其他写者是互斥的，和其他读者是不互斥的 编程思路 做一个临界资源类，包含读者写者共同共享数据区，和对这个数据的读写操作 利用C++11提供的 mutex 类，用 “使用成员函数指针作为线程函数” 的方法建立多个读者写者线程 为了自动生成读者的数据，给每个写者一个私有
操作系统 读者写者问题的实现（C++ 读者优先、写者优先）
hhypractise的博客
07-06 2万+
通过信号量机制和相应的系统调用，用于线程的互斥和同步，实现读者写者问题。利用信号量机制，实现读者写者问题。 在windows 10环境下，创建一个控制台进程，此进程包含n个线程。用这n个线程来表示n个读者或写者。每个线程按照设定进行读写操作。用信号量机制分别实现读者优先和写者优先的读者写者问题。 读者和写者问题的读写操作限制（包括读者优先和写者优先）： 写写互斥：即不能有两个写者同时进行写操作。 **读写互斥：**即不能同时有一个线程在读，而另一个线程在写。 **读读允许：**即可以有一个或多个读者在读。
操作系统实验：读者写者问题
qq_50542009的博客
06-26 9566
一．实验目的： 通过实现读者写者问题理解进程及信号量的概念 二．实验要求： 创建一个控制台进程，此进程包含n个线程。用这n个线程来表示n个读者或写者。每个线程按相应测试数据文件的要求进行读写操作。用信号量机制分别实现读者优先和写者优先的读者-写者问题。 三．实验内容： 利用多线程模拟读者与写者对临界区的互斥访问。读者和写者问题的读写操作限制： 可以有一个或多个数量的读进程同时读这个文件；一次只有一个写进程可以写文件；若一个写进程正在写文件，则禁止任何读进程读文件；即读读允许、读写互斥、写写互斥.
读者写者问题怎么实现啊，在线等，挺急的
qq_41372083的博客
07-12 385
在Linux0.11内核中实现信号量的系统调用，然后利用信号量机制实现在多个并发程序环境下的读者写者问题。利用Linux0.11内核提供的sleep_on函数和wake_up函数实现信号量的阻塞与唤醒；...
不同优先级的读者写者问题实现
H_idea的博客
02-10 285
弱读者优先 在这一版本的实现中需要在已经有读者在读的情况下优先响应正在等待的读者而不是写者，代码如下： int rc = 0; sem_t mutex, w; void reader() { while(true) { P(&mutex); rc++; if(rc == 1) P(&w); V(&mutex); ...read... P(&mutex);
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值