blocks|key|1489681|text|你可以复制Sun公司优秀的ReentrantReadWriteLock。它包括一些特性，比如可选的公平性、锁降级，当然还有可重入性。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1489682|是的，它是用Java写的，但是即使你不懂Java，你也可以很容易地读懂它，并把它转换成C%2B%2B。我链接的文档包含此实现的所有行为属性，因此您可以确保它执行您想要的操作。|1489683|就算没有别的，它也是一本指南。|1489684|entityMap|0|LINK|mutability|MUTABLE|url|http://java.sun.com/j2se/1.5.0/docs/api/java/util/concurrent/locks/ReentrantReadWriteLock.html^0|D|M|0|0|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@$A|Q|B|R|1|S]]|C|$]]|$1|D|3|E|5|6|7|T|8|@]|9|@]|C|$]]|$1|F|3|G|5|6|7|U|8|@]|9|@]|C|$]]|$1|H|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|I|$J|$5|K|L|M|C|$N|O]]]]

You could copy Sun's excellent <a href="http://java.sun.com/j2se/1.5.0/docs/api/java/util/concurrent/locks/ReentrantReadWriteLock.html" rel="nofollow noreferrer">ReentrantReadWriteLock</a>. It includes features such as optional fairness, lock downgrading, and of course reentrancy.

Yes it's in Java, but you can easily read and transpose it to C++, even if you don't know any Java. The documentation I linked to contains all the behavioral properties of this implementation so you can make sure it does what you want.

If nothing else, it's a guide.

blocks|key|1704752|text|较新版本的boost::thread具有读/写锁定(1.35.0及更高版本，显然以前的版本无法正常工作)。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1704753|它们的名称分别为shared_lock、unique_lock和upgrade_lock，并在shared_mutex上运行。|style|CODE|1704754|entityMap|0|LINK|mutability|MUTABLE|url|http://www.boost.org/doc/libs/1_50_0/doc/html/thread.html|1|http://www.boost.org/doc/libs/1_50_0/doc/html/thread/synchronization.html#thread.synchronization.locks.unique_lock|2|http://www.boost.org/doc/libs/1_50_0/doc/html/thread/synchronization.html#thread.synchronization.locks.shared_lock|3|http://www.boost.org/doc/libs/1_50_0/doc/html/thread/synchronization.html#thread.synchronization.locks.upgrade_lock|4|http://www.boost.org/doc/libs/1_50_0/doc/html/thread/synchronization.html#thread.synchronization.mutex_types.shared_mutex^0|5|D|0|0|8|B|K|B|W|C|1B|C|8|B|1|K|B|2|W|C|3|1B|C|4|0^^$0|@$1|2|3|4|5|6|7|X|8|@]|9|@$A|Y|B|Z|1|10]]|C|$]]|$1|D|3|E|5|6|7|11|8|@$A|12|B|13|F|G]|$A|14|B|15|F|G]|$A|16|B|17|F|G]|$A|18|B|19|F|G]]|9|@$A|1A|B|1B|1|1C]|$A|1D|B|1E|1|1F]|$A|1G|B|1H|1|1I]|$A|1J|B|1K|1|1L]]|C|$]]|$1|H|3|-4|5|6|7|1M|8|@]|9|@]|C|$]]]|I|$J|$5|K|L|M|C|$N|O]]|P|$5|K|L|M|C|$N|Q]]|R|$5|K|L|M|C|$N|S]]|T|$5|K|L|M|C|$N|U]]|V|$5|K|L|M|C|$N|W]]]]

Newer versions of <a href="http://www.boost.org/doc/libs/1_50_0/doc/html/thread.html" rel="noreferrer">boost::thread</a> have read/write locks (1.35.0 and later, apparently the previous versions did not work correctly).

They have the names <a href="http://www.boost.org/doc/libs/1_50_0/doc/html/thread/synchronization.html#thread.synchronization.locks.unique_lock" rel="noreferrer"><code>shared_lock</code></a>, <a href="http://www.boost.org/doc/libs/1_50_0/doc/html/thread/synchronization.html#thread.synchronization.locks.shared_lock" rel="noreferrer"><code>unique_lock</code></a>, and <a href="http://www.boost.org/doc/libs/1_50_0/doc/html/thread/synchronization.html#thread.synchronization.locks.upgrade_lock" rel="noreferrer"><code>upgrade_lock</code></a> and operate on a <a href="http://www.boost.org/doc/libs/1_50_0/doc/html/thread/synchronization.html#thread.synchronization.mutex_types.shared_mutex" rel="noreferrer"><code>shared_mutex</code></a>.

blocks|key|1489822|text|使用标准的预先测试的、预先构建的东西总是很好的(例如，另一个答案建议的Boost+)，但这不是很难自己构建的东西。这是从我的一个项目中提取的一个愚蠢的小实现：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1489823|#include+<pthread.h>

struct+rwlock+{
++++pthread_mutex_t+lock;
++++pthread_cond_t+read,+write;
++++unsigned+readers,+writers,+read_waiters,+write_waiters;
};

void+reader_lock(struct+rwlock+*self)+{
++++pthread_mutex_lock(&self->lock);
++++if+(self->writers+%7C%7C+self->write_waiters)+{
++++++++self->read_waiters%2B%2B;
++++++++do+pthread_cond_wait(&self->read,+&self->lock);
++++++++while+(self->writers+%7C%7C+self->write_waiters);
++++++++self->read_waiters--;
++++}
++++self->readers%2B%2B;
++++pthread_mutex_unlock(&self->lock);
}

void+reader_unlock(struct+rwlock+*self)+{
++++pthread_mutex_lock(&self->lock);
++++self->readers--;
++++if+(self->write_waiters)
++++++++pthread_cond_signal(&self->write);
++++pthread_mutex_unlock(&self->lock);
}

void+writer_lock(struct+rwlock+*self)+{
++++pthread_mutex_lock(&self->lock);
++++if+(self->readers+%7C%7C+self->writers)+{
++++++++self->write_waiters%2B%2B;
++++++++do+pthread_cond_wait(&self->write,+&self->lock);
++++++++while+(self->readers+%7C%7C+self->writers);
++++++++self->write_waiters--;
++++}
++++self->writers+=+1;
++++pthread_mutex_unlock(&self->lock);
}

void+writer_unlock(struct+rwlock+*self)+{
++++pthread_mutex_lock(&self->lock);
++++self->writers+=+0;
++++if+(self->write_waiters)
++++++++pthread_cond_signal(&self->write);
++++else+if+(self->read_waiters)
++++++++pthread_cond_broadcast(&self->read);
++++pthread_mutex_unlock(&self->lock);
}

void+rwlock_init(struct+rwlock+*self)+{
++++self->readers+=+self->writers+=+self->read_waiters+=+self->write_waiters+=+0;
++++pthread_mutex_init(&self->lock,+NULL);
++++pthread_cond_init(&self->read,+NULL);
++++pthread_cond_init(&self->write,+NULL);
}|code-block|syntax|javascript|1489824|pthreads并不是Windows原生的，但大意就在这里。这个实现稍微偏向于编写者(一大群编写者可能会无限期地让读者挨饿)；如果您希望平衡反过来，只需修改writer_unlock即可。|offset|length|style|CODE|1489825|是的，这是C而不是C%2B%2B。翻译是留给读者的练习。|1489826|编辑|1489827|Greg+Rogers指出，POSIX标准确实指定了pthread_rwlock_*。如果你没有pthreads，这不会有什么帮助，但它激起了我的记忆：Pthreads-w32应该可以工作！不要将这段代码移植到非pthreads上供您自己使用，只需在Windows上使用Pthreads+w32，在其他地方使用原生pthreads即可。|1489828|entityMap|0|LINK|mutability|MUTABLE|url|http://sourceware.org/pthreads-win32/^0|0|0|0|8|26|D|0|0|0|Q|G|1C|8|2Y|8|4D|8|24|C|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|12|8|@$I|13|J|14|K|L]|$I|15|J|16|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|17|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|18|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|19|8|@$I|1A|J|1B|K|L]|$I|1C|J|1D|K|L]|$I|1E|J|1F|K|L]|$I|1G|J|1H|K|L]]|9|@$I|1I|J|1J|1|1K]]|A|$]]|$1|S|3|-4|5|6|7|1L|8|@]|9|@]|A|$]]]|T|$U|$5|V|W|X|A|$Y|Z]]]]

Using standard pre-tested, pre-built stuff is always good (for example, Boost as another answer suggested), but this is something that's not too hard to build yourself. Here's a dumb little implementation pulled out from a project of mine:

<pre><code>#include &lt;pthread.h&gt;

struct rwlock {
 pthread_mutex_t lock;
 pthread_cond_t read, write;
 unsigned readers, writers, read_waiters, write_waiters;
};

void reader_lock(struct rwlock *self) {
 pthread_mutex_lock(&amp;self-&gt;lock);
 if (self-&gt;writers || self-&gt;write_waiters) {
 self-&gt;read_waiters++;
 do pthread_cond_wait(&amp;self-&gt;read, &amp;self-&gt;lock);
 while (self-&gt;writers || self-&gt;write_waiters);
 self-&gt;read_waiters--;
 }
 self-&gt;readers++;
 pthread_mutex_unlock(&amp;self-&gt;lock);
}

void reader_unlock(struct rwlock *self) {
 pthread_mutex_lock(&amp;self-&gt;lock);
 self-&gt;readers--;
 if (self-&gt;write_waiters)
 pthread_cond_signal(&amp;self-&gt;write);
 pthread_mutex_unlock(&amp;self-&gt;lock);
}

void writer_lock(struct rwlock *self) {
 pthread_mutex_lock(&amp;self-&gt;lock);
 if (self-&gt;readers || self-&gt;writers) {
 self-&gt;write_waiters++;
 do pthread_cond_wait(&amp;self-&gt;write, &amp;self-&gt;lock);
 while (self-&gt;readers || self-&gt;writers);
 self-&gt;write_waiters--;
 }
 self-&gt;writers = 1;
 pthread_mutex_unlock(&amp;self-&gt;lock);
}

void writer_unlock(struct rwlock *self) {
 pthread_mutex_lock(&amp;self-&gt;lock);
 self-&gt;writers = 0;
 if (self-&gt;write_waiters)
 pthread_cond_signal(&amp;self-&gt;write);
 else if (self-&gt;read_waiters)
 pthread_cond_broadcast(&amp;self-&gt;read);
 pthread_mutex_unlock(&amp;self-&gt;lock);
}

void rwlock_init(struct rwlock *self) {
 self-&gt;readers = self-&gt;writers = self-&gt;read_waiters = self-&gt;write_waiters = 0;
 pthread_mutex_init(&amp;self-&gt;lock, NULL);
 pthread_cond_init(&amp;self-&gt;read, NULL);
 pthread_cond_init(&amp;self-&gt;write, NULL);
}
</code></pre>

<code>pthreads</code> not really being Windows-native, but the general idea is here. This implementation is slightly biased towards writers (a horde of writers can starve readers indefinitely); just modify <code>writer_unlock</code> if you'd rather the balance be the other way around.

Yes, this is C and not C++. Translation is an exercise left to the reader.

<h2>Edit</h2>

Greg Rogers pointed out that the POSIX standard does specify <code>pthread_rwlock_*</code>. This doesn't help if you don't have <code>pthreads</code>, but it stirred my mind into remembering: <a href="http://sourceware.org/pthreads-win32/" rel="noreferrer">Pthreads-w32</a> should work! Instead of porting this code to non-<code>pthreads</code> for your own use, just use Pthreads-w32 on Windows, and native <code>pthreads</code> everywhere else.

blocks|key|1704893|text|从版本1.35.0开始，Boost.Thread就已经支持读写器锁定。这样做的好处是它的实现很大程度上是跨平台的、经过同行评审的，而且实际上是a+reference+implementation+for+the+upcoming+C%2B%2B0x+standard的。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1704894|entityMap|0|LINK|mutability|MUTABLE|url|http://www.boost.org/doc/libs/1_36_0/doc/html/thread.html|1|http://www.ddj.com/cpp/211600441?pgno=3^0|C|C|0|1Z|1M|1|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@$A|O|B|P|1|Q]|$A|R|B|S|1|T]]|C|$]]|$1|D|3|-4|5|6|7|U|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]|L|$5|G|H|I|C|$J|M]]]]

<a href="http://www.boost.org/doc/libs/1_36_0/doc/html/thread.html" rel="nofollow noreferrer">Boost.Thread</a> has since release 1.35.0 already supports reader-writer locks. The good thing about this is that the implementation is greatly cross-platform, peer-reviewed, and is actually <a href="http://www.ddj.com/cpp/211600441?pgno=3" rel="nofollow noreferrer">a reference implementation for the upcoming C++0x standard</a>.

blocks|key|1704960|text|无论您决定使用什么，都要根据简单锁对您的工作负载进行基准测试，因为在没有争用的情况下，读/写锁往往比简单互斥锁慢3-40倍。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1704961|这是some+reference|offset|length|1704962|entityMap|0|LINK|mutability|MUTABLE|url|http://www.zeroc.com/doc/Ice-3.3.0-IceTouch/manual/Threads.32.10.html^0|0|2|E|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@$D|P|E|Q|1|R]]|A|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|G|$H|$5|I|J|K|A|$L|M]]]]

Whatever you decide to use, benchmark your work load against simple locks, as read/write locks tend to be 3-40x slower than simple mutex, when there is no contention.

Here is <a href="http://www.zeroc.com/doc/Ice-3.3.0-IceTouch/manual/Threads.32.10.html" rel="noreferrer">some reference</a>

blocks|key|1489990|text|英特尔线程构建模块还提供了两个rw_lock变体：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1489991|http://www.threadingbuildingblocks.org/|offset|length|1489992|它们具有用于极短争用周期的spin_rw_mutex和用于较长争用周期的queueing_rw_mutex。前者可用于对性能特别敏感的代码。后者在性能上与Boost.Thread提供的或直接使用pthread提供的性能更接近。但配置文件，以确保哪一个是您的访问模式的胜利。|1489993|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|13|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@$D|Q|E|R|1|S]]|A|$]]|$1|F|3|G|5|6|7|T|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|U|8|@]|9|@]|A|$]]]|I|$J|$5|K|L|M|A|$N|C]]]]

Intel Thread Building Blocks also provide a couple of rw_lock variants:

<a href="http://www.threadingbuildingblocks.org/" rel="nofollow noreferrer">http://www.threadingbuildingblocks.org/</a>

They have a spin_rw_mutex for very short periods of contention and a queueing_rw_mutex for longer periods of contention. The former can be used in particularly performance sensitive code. The latter is more comparable in performance to that provided by Boost.Thread or directly using pthreads. But profile to make sure which one is a win for your access patterns.

blocks|key|1705112|text|编辑:+MSDN杂志链接不再可用。这篇CodeProject文章现在可以在https://www.codeproject.com/Articles/32685/Testing-reader-writer-locks上找到，并且做了很好的总结。我还发现了一个关于Compound+Synchronisation+Objects的新的MSDN链接。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1705113|在MSDN上有一个关于读取器-写入器锁的article，介绍了它们的一些实现。它还引入了Slim读取器/写入器锁，这是Vista引入的内核同步原语。还有一个关于比较不同实现(包括MSDN文章的实现)的CodeProject+article。|1705114|entityMap|0|LINK|mutability|MUTABLE|url|https://www.codeproject.com/Articles/32685/Testing-reader-writer-locks|1|https://msdn.microsoft.com/en-us/library/ms810427.aspx|2|http://msdn.microsoft.com/en-us/magazine/cc163405.aspx|3|http://www.codeproject.com/KB/threads/testing_rwlocks.aspx^0|11|1Y|0|3M|W|1|0|K|7|2|2S|J|3|0^^$0|@$1|2|3|4|5|6|7|T|8|@]|9|@$A|U|B|V|1|W]|$A|X|B|Y|1|Z]]|C|$]]|$1|D|3|E|5|6|7|10|8|@]|9|@$A|11|B|12|1|13]|$A|14|B|15|1|16]]|C|$]]|$1|F|3|-4|5|6|7|17|8|@]|9|@]|C|$]]]|G|$H|$5|I|J|K|C|$L|M]]|N|$5|I|J|K|C|$L|O]]|P|$5|I|J|K|C|$L|Q]]|R|$5|I|J|K|C|$L|S]]]]

Edit: The MSDN Magazine link isn't available anymore. The CodeProject article is now available on <a href="https://www.codeproject.com/Articles/32685/Testing-reader-writer-locks" rel="nofollow noreferrer">https://www.codeproject.com/Articles/32685/Testing-reader-writer-locks</a> and sums it up pretty nicely. Also I found a new MSDN link about <a href="https://msdn.microsoft.com/en-us/library/ms810427.aspx" rel="nofollow noreferrer">Compound Synchronisation Objects</a>.

There is an <a href="http://msdn.microsoft.com/en-us/magazine/cc163405.aspx" rel="nofollow noreferrer">article</a> about reader-writer locks on MSDN that presents some implementations of them. It also introduces the Slim reader/writer lock, a kernel synchronisation primitive introduced with Vista. There's also a <a href="http://www.codeproject.com/KB/threads/testing_rwlocks.aspx" rel="nofollow noreferrer">CodeProject article</a> about comparing different implementations (including the MSDN article's ones).

blocks|key|1490122|text|http://www.codeproject.com/KB/threads/ReaderWriterLock.aspx|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1490123|这是一个很好的轻量级实现，适用于大多数任务。|1490124|entityMap|0|LINK|mutability|MUTABLE|url^0|0|1N|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@$A|N|B|O|1|P]]|C|$]]|$1|D|3|E|5|6|7|Q|8|@]|9|@]|C|$]]|$1|F|3|-4|5|6|7|R|8|@]|9|@]|C|$]]]|G|$H|$5|I|J|K|C|$L|4]]]]

<a href="http://www.codeproject.com/KB/threads/ReaderWriterLock.aspx" rel="nofollow">http://www.codeproject.com/KB/threads/ReaderWriterLock.aspx</a>

Here is a good and lightweight implementation suitable for most tasks.

blocks|key|1705188|text|Glenn+Slayde的Win32多读取器、单写入器同步锁类|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1705189|http://www.glennslayden.com/code/win32/reader-writer-lock|offset|length|1705190|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|1L|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@$D|O|E|P|1|Q]]|A|$]]|$1|F|3|-4|5|6|7|R|8|@]|9|@]|A|$]]]|G|$H|$5|I|J|K|A|$L|C]]]]

Multiple-Reader, Single-Writer Synchronization Lock Class for Win32 by Glenn Slayde

<a href="http://www.glennslayden.com/code/win32/reader-writer-lock" rel="nofollow">http://www.glennslayden.com/code/win32/reader-writer-lock</a>

blocks|key|1490179|text|C%2B%2B17支持std::shared_mutex。MSVC%2B%2B+2015和2017版本均支持。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1490180|entityMap|0|LINK|mutability|MUTABLE|url|http://en.cppreference.com/w/cpp/thread/shared_mutex|1|https://msdn.microsoft.com/en-us/library/mt420524.aspx?f=255&MSPPError=-2147217396^0|7|H|7|H|0|P|B|1|0^^$0|@$1|2|3|4|5|6|7|P|8|@$9|Q|A|R|B|C]]|D|@$9|S|A|T|1|U]|$9|V|A|W|1|X]]|E|$]]|$1|F|3|-4|5|6|7|Y|8|@]|D|@]|E|$]]]|G|$H|$5|I|J|K|E|$L|M]]|N|$5|I|J|K|E|$L|O]]]]

C++17 supports <a href="http://en.cppreference.com/w/cpp/thread/shared_mutex" rel="noreferrer"><code>std::shared_mutex</code></a> . It is supported in <a href="https://msdn.microsoft.com/en-us/library/mt420524.aspx?f=255&amp;MSPPError=-2147217396" rel="noreferrer">MSVC++ 2015</a> and 2017.

I'm looking for a good reader/writer lock in C++. We have a use case of a single infrequent writer and many frequent readers and would like to optimize for this. Preferable I would like a cross-platform solution, however a Windows only one would be acceptable.

Reader/Writer Locks in C++

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我正在寻找一个好的C++读写器锁。我们有一个单一的不频繁的写入者和许多频繁的读者的用例，并希望对此进行优化。我想要一个跨平台的解决方案，但是Windows只有一个是可以接受的。

问C++中的读取器/写入器锁定
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问C++中的读取器/写入器锁定EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问C++中的读取器/写入器锁定
EN