如何从更基本的同步原语创建多读/单写锁？

乍一看，我认为我认识到这个答案和亚历山大·特列霍夫介绍的算法是一样的。但经过研究，我认为它是有缺陷的。两个写入程序可以同时等待m_exclusive_cond。当其中一个写入程序唤醒并获得独占锁时，它会将独占\u waiting\u blocked=false设置为打开解锁，从而将互斥锁设置为不一致的状态。在那之后，互斥锁可能会被冲洗掉

N2406首先提出了std:：shared_mutex，它包含一个部分实现，下面用更新的语法重复该部分实现

类共享\u互斥
{
互斥互斥；
条件变量门1；
条件变量门2；
无符号状态；
静态常量无符号写入\u输入=1U&lt；；（sizeof（无符号）*字符\u位-1）；
静态常量未签名n\u读取器\u=~ write\u输入\u；
公众：
共享的互斥体（）：状态{（0）{}
//专有权
无效锁（）；
bool try_lock（）；
无效解锁（）；
//共享所有权
void lock_shared（）；
bool try_lock_shared（）；
void unlock_shared（）；
};
//专有权
无效的
共享互斥体：：锁（）
{
唯一锁&lt；互斥锁&gt；lk（多锁）；
while（输入状态和写入状态）
网关1。等待（lk）；
状态124;=写入124;输入124;；
while（state_和n_readers_）
网关2。等待（lk）；
}
布尔
共享互斥锁：：try_lock（）
{
唯一锁&lt；互斥锁&gt；lk（多锁，尝试锁）；
if（lk.owns_lock（）&amp；state_==0）
{
状态=写入输入的状态；
返回true；
}
返回false；
}
无效的
共享互斥体：：解锁（）
{
{
锁定保护&lt；互斥&gt；u（mut）；
状态=0；
}
gate1.通知所有人（）；
}
//共享所有权
无效的
共享互斥锁：：锁共享（）
{
唯一锁&lt；互斥锁&gt；lk（多锁）；
while（（state_&amp；write_输入）| |（state_&amp；n_读卡器）==n_读卡器）
网关1。等待（lk）；
unsigned num_readers=（state_u和n_readers）+1；
州=n读者；
state|=num_读取器；
}
布尔
共享互斥锁：：try_lock_shared（）
{
唯一锁&lt；互斥锁&gt；lk（多锁，尝试锁）；
unsigned num_readers=state_u&amp；n_readers\uu；
if（lk.owns_lock（）&amp；！（state_&amp；write_entered_）&amp；num_readers！=n_readers_）
{
++num_阅读器；
州=n读者；
state|=num_读取器；
返回true；
}
返回false；
}
无效的
共享互斥锁：：解锁共享
{
锁定保护&lt；互斥&gt；u（mut）；
unsigned num_readers=（state_u&amp；n_readers_u）-1；
州=n读者；
state|=num_读取器；
如果（输入状态和写入状态）
{
if（num_readers==0）
网关2。通知网关1（）；
}
其他的
{
if（num\u readers==n\u readers\u1）
网关1。通知网关1（）；
}
}

该算法源自Alexander Terekhov的旧新闻组帖子。它既不让读者也不让作家挨饿

有两个“门”gate1和gate2。读者和作者必须通过gate1，这样做可能会被阻止。一旦读卡器通过gate1，它就已经读取并锁定了互斥锁。只要拥有所有权的读卡器数量不超过上限，并且只要写入者没有通过gate1，读卡器就可以通过gate1