算法思想来自这本书，我在该基础上换成了C++的版本，直接可以在VS下运行成功

读者优先

#include<bits/stdc++.h>
#include <mutex>
using namespace std;
mutex rmutex;		//初始化信号量mutext,用于保持readcount的互斥访问
mutex helpmutex;	//初始化信号量，用于保证对于数据区的写互斥
int readercount = 0;	//用于记录读者数量，初始值为0


static void Reader()
{
	while (true)					//循环执行这段代码
	{
		rmutex.lock();			   //申请readCount的使用权，对应于书上的P(rmutex)
		if (readercount == 0)
		{
			helpmutex.lock();	 //如果为第一个读者，要阻止写者进入，对应书上的P(helpmutext)
		}
		++readercount;			//读者数量加1
		rmutex.unlock();		//释放readercount的使用权，允许其他读者使用,对应于书上的P(rmutext);
		
		//进行读操作

		rmutex.lock();			//申请readercount的使用，要对其进行操作
		--readercount;			//读者数量减1
		if (0 == readercount)
		{
			helpmutex.unlock();  //如果没有了读者，则允许写者进入，对应于书上的V(helpmutext)
		}
		rmutex.unlock();		//释放readercount的使用,允许其他读者或者写者使用
	}
}

static void writer()
{
	while (true)			//循环执行这段代码
	{
		helpmutex.lock();	//申请对数据区进行访问

		//进行写操作

		helpmutex.unlock();	//释放数据区，允许其他进程读写
	}
}

int main()
{
	system("pause");
	return 0;
}

公平情况-------按照达到的先后顺序进行操作

#include<bits/stdc++.h>
#include <mutex>
using namespace std;

static mutex helpmutext;	//初始化mutext，用于控制互斥访问数据区
static mutex rmutex;		//初始化rmutext，用于读者互斥访问readcount
static mutex wmutex;		//初始化wmutext，用于存在写者时候禁止新读者进入

static int readcount = 0;	//用于记录读者数量，初始值为0

static void reader()		
{
	while (true)
	{
		wmutex.lock();		//检测是否有写者存在，无写者时进入,对应书上的P(wmutex)
		rmutex.lock();		//申请使用readcount，对应书上的P(rmutex)
		if (readcount == 0)
		{
			helpmutext.lock(); //如果为第一个读者，要阻止写者进入,对应书上的P(helpmutx)
		}
		++readcount;			// 读者数量加1
		rmutex.unlock();	  //释放readcount的使用权，允许其他读者使用,对应书上的P(rmutex)

		wmutex.unlock();	  //恢复wmutex，对应于书上的V(wmutex)

		//进行读操作

		rmutex.lock();
		--readcount;
		if (0 == readcount)
		{
			helpmutext.unlock();
		}
		rmutex.unlock();
	}
}

static void writer()
{
	wmutex.lock();			//检测是否有其他读者存在，无写者时进入
	helpmutext.lock();		//申请读数据区的访问

	//进行写操作
		
	helpmutext.unlock();	//释放数据区，允许其他进程进行读写
	wmutex.unlock();		//恢复wmutext

}

写者优先算法

#include<bits/stdc++.h>
#include <mutex>
using namespace std;

static mutex helpmutext;	//初始化mutext，用于控制互斥访问数据区
static mutex rmutex;		//初始化rmutext，用于读者互斥访问readcount
static mutex wmutex;		//初始化wmutext，用于存在写者时候禁止新读者进入
static mutex readable;		//初始化readable，用于表示当前是否有写者

static int readcount = 0, writecount = 0; // 分别用于记录读者和写者的数量，初值均为0

static void reader()
{
	readable.lock();		//检查是否存在写者，如果没有则占用进行后续操作
	rmutex.lock();			//占用rmutex，准备修改readcount
	if ( 0 == readcount)
	{
		helpmutext.lock();	//如果是第一个读者，则占用数据区
	}
	++readcount;			//读者数量加1
	rmutex.unlock();		//释放rmutex，允许其他读者访问readcount
	readable.unlock();		//释放readable，允许其他读者或者写者占用

	//读操作 

	rmutex.lock();			//占用rmutex，准备修改readcount
	--readcount;
	if ( 0 == readcount)
	{
		helpmutext.unlock();
	}
	rmutex.unlock();
}

static void writer()
{
	wmutex.lock();			//占用wmutext，准备修改writecount
	if ( 0 == writecount)	//若为第一个写者，则阻止后续读者进入
	{
		readable.lock();
	}	
	++writecount;			//写者数量加1
	wmutex.unlock();		//释放wmutex，允许其他写者修改writecount

	helpmutext.lock();		//等当前正在操作的读者或者写者完成之后，占用数据区

	//写操作

	helpmutext.unlock();	//写完，释放数据区

	wmutex.lock();			//占用wmutext，准备修改writecount
	--writecount;			//写者数量减1
	if (writecount == 0)
	{
		readable.unlock();	//如果是最后一个写者，允许读者进入
	}
	wmutex.unlock();		//释放wmutex，允许其他写者修改writecount
}