3回答
读锁写锁
、、、、
我对读和写锁有点不确定，只是需要有人来检查一下，关于读/写锁的这些事实是否正确。
这指的是一般的数据库。
读锁：
多个读锁可以由多个线程同时获得。
当线程在行/表上有读锁时，没有线程可以更新/插入/删除该表中的数据。(即使试图写入数据的线程不需要写锁。)
行/表不能同时具有读锁和写锁。
写锁：
当一个行/表有写锁时，如果另一个线程实现了读锁，它就不能被另一个线程读取，但是如果没有实现读锁(即简单选择查询)，其他线程可以读取它。
谢谢你的澄清。我在互联网上找不到对这些声明的直接断言。
浏览 4提问于2011-10-10得票数 38
我想确定：
读锁：
如果线程在读锁中，另一个线程也可以进入这个读锁或另一个读锁，但是任何线程都可以进入写锁，而一个或多个线程在读锁中。
写锁：
如果线程在写锁中，那么任何线程都可以进入写锁或读锁。
浏览 1提问于2014-03-08得票数 2
回答已采纳
2回答
根据MySQL文档，如果任何会话都持有表的读锁，则另一个会话请求同一表的写锁，则必须给出写锁，并等待读锁。
我试过了，从两个控制台(Windows7)连接到MySQL服务器。从第一个控制台锁定表A(读锁)，然后尝试从第二个控制台锁定相同的表(写锁)，但是第二个控制台只是等待第一个锁释放。
谁错了:我还是文件？(MySQL服务器5.5.27版)
来自MySQL官方文件的引文：
“写锁通常比读锁具有更高的优先级，以确保尽快处理更新。这意味着如果一个会话获得一个读锁，而另一个会话请求一个写锁，则随后的读锁请求等待请求写入锁的会话获得并释放它。”
浏览 5提问于2012-08-29得票数 1
回答已采纳
情况：
程序正在使用pthread_rwlock_t，比如foolock
一个线程(比如T1 )获取foolock上的写锁(使用pthread_rwlock_wrlock()获得)
T1试图获取foolock上的读锁(pthread_rwlock_rdlock())
没有其他线程在foolock上拥有读锁或写锁。
有匹配的解锁。
预计会发生什么？
程序(特别是T1)接收一个错误：
pthread_rwlock_rdlock() returns EDEADLK ("Resource deadlock avoided").
选择这种行为的动机是什么？如果
浏览 5提问于2014-07-02得票数 0
当发生mongoDB写入时，读取必须等待或不等待。当mongoDB打算在mongodb中编写一些文档时，会发生写锁，而其他线程试图读取其他文档时，应该等到写锁释放或不释放时再执行。所有读锁和写锁之间是否存在依赖关系？
浏览 2提问于2014-12-05得票数 3
回答已采纳
在中，作者通过阅读和写作来讨论饥饿问题：
正当你认为有足够的问题需要考虑的时候，一个新的问题即将来临。锁定共享资源可能会导致读写器问题。在许多情况下，将对资源的读取访问限制为一次一次访问是浪费的。因此，只要资源上没有写入锁，就允许使用读锁。在这种情况下，等待获得写锁的线程可能会被同时发生的更多读锁所饥饿。
我假设读取锁只允许锁定它的对象访问读取值，而其他所有的对象都无法访问它？我知道，只有在没有写锁的情况下才能读取锁(因为值可能正在改变)，但是在它使用的方式上，它似乎意味着“只有在没有写锁的情况下才允许读锁”作为一种效率/不浪费的手段。采取一个阅读锁与浪费有什么关系？
还有，有人能解释
浏览 4提问于2014-01-13得票数 1
回答已采纳
考虑一下这个JDK标准接口：
public interface ReadWriteLock{
public Lock readLock();
public Lock writeLock();
}
B. Goetz在Java中的并发性实际上提到了从readLock升级到writeLock是很容易死锁的。
如果两个读取器同时尝试升级到写锁，则两者都不会实现读锁。
让我感到困惑的是，是两个阅读器试图升级。但即使是一个读者也足够了，不是吗？如果读取器试图升级，它还没有释放读锁。试图用所持有的读锁获取写锁是死锁。
因此，从这一点来看，我认为提供升级操作在理论上甚至是荒谬的。或者一
浏览 5提问于2016-05-07得票数 3
回答已采纳
3回答
下面的代码中出现了死锁情况：
private static final ReadWriteLock opClassesLock = new ReentrantReadWriteLock();
private static final Map<Class<?>, ServiceClass> opClasses = new WeakHashMap<Class<?>, ServiceClass>();
public static ServiceClass get(Class<?> myClass) {
opClassesLock.r
浏览 3提问于2011-02-03得票数 2
回答已采纳
4回答
我在Linux上使用读/写锁，并且我发现试图将读锁对象升级为写锁死锁。
即
// acquire the read lock in thread 1.
pthread_rwlock_rdlock( &lock );
// make a decision to upgrade the lock in threads 1.
pthread_rwlock_wrlock( &lock ); // this deadlocks as already hold read lock.
我读过手册页，它很具体。
调用线程如果在调用时持有读-写锁(无论是读锁还是写锁)，则可能会死锁。
在这种
浏览 1提问于2010-03-09得票数 16
回答已采纳
1回答
为了理解Java 8中的乐观锁定，我遇到了以下代码。。
正如在博客中解释的那样，这段代码试图将读锁转换为写lock.The代码，如果读锁转换为写锁失败，则请求显式写锁。
令我费解的是，，当父线程已经持有读锁时，怎么可能会授予显式写锁呢？--在强制请求写锁之前，它看起来并不像读取锁在任何时候都被释放。据我错误的理解，线程会无限地等待写锁，因为读取锁从未释放，从而造成死锁。
，为什么这不会导致这里的死锁？
ExecutorService executor = Executors.newFixedThreadPool(2);
StampedLock lock = new StampedLock();
浏览 8提问于2021-01-13得票数 0
什么是ReentrantReadWriteLock的升级/降级？我看到关于升级/降级：
锁定降级:可重入性还允许将写入锁降级为读锁，方法是获取写锁，然后读取锁，然后释放写锁。然而，从读锁升级到写锁是不可能的。
并提供了一个样本：
class CachedData {
Object data;
volatile boolean cacheValid;
ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
void processCachedData() {
rwl.readLock().lock(
浏览 4提问于2011-02-21得票数 8
回答已采纳
从
void processCachedData() {
rwl.readLock().lock();
if (!cacheValid) {
// Must release read lock before acquiring write lock
5: rwl.readLock().unlock();
6: rwl.writeLock().lock();
// Recheck state because another thread might have acquired
// write lock and changed state bef
浏览 2提问于2013-06-04得票数 6
回答已采纳
2回答
两相锁定是用于确保串行执行的解决方案。但是，我不确定它如何在读-修改-写周期中充分解决丢失的更新问题。我可能忽略了/误解了这里的锁定机制！
例如，假设有一个使用2PL运行的数据库：
给定具有整数列account的SQL表email_count，让我们假设数据库中有以下记录：
| ID | email_count |
| ----- | ----- |
| 1 | 0 |
现在假设我们有两个并发执行的事务，T1和T2。这两个事务都将从ID =1的email_count中读取accounts，将计数值增加1，并写入结果。
这里有一个场景，其中2PL似乎没有解决丢失的更新问题(T1代表事
浏览 5提问于2022-03-20得票数 1
回答已采纳
关于Java语言中的ReadWriteLocks (特别是ReentrantReadWriteLock实现)，我只想提一个简短的问题，因为我觉得sun文档并不清楚。
如果一个线程持有一个读锁，而另一个线程请求一个写锁，会发生什么？写锁线程是否必须等待当前持有的所有读锁被释放？另外，是否所有新的读锁请求都会被阻塞，直到写锁被授予并释放？
谢谢
浏览 7提问于2009-07-07得票数 0
回答已采纳
我在这个线程问题上是个新手:\
我设想写锁的行为就像等待全局变量确认的while。比如：
/* pthread_rwlock_wrlock */
while (is_blocked) {
/* waiting */
}
is_blocked = true;
(writing code...)
/* pthread_rwlock_unlock */
is_blocked = false;
对吗？那么读锁是怎么工作的呢？如果它是共享的，为什么要使用它？
信息：
pthread_rwlock_rdlock() -获取共享的读锁
pthre
浏览 4提问于2017-02-15得票数 1
1回答
我是否正确地指出，获取StampedLock锁的这两种方法之间的唯一区别是：
stampedLock.readLock();
stampedLock.tryOptimisticRead();
当读锁至少由一个线程持有时，写锁不能接受；而乐观读允许获得写锁吗？
浏览 4提问于2015-12-03得票数 1
回答已采纳
我对的理解是，它允许多个同时读取，但只允许一次写入。
当我们试图获取读锁时，状态
Acquires the read lock if the write lock is not held by another thread and returns immediately.
If the write lock is held by another thread then the current thread becomes disabled
for thread scheduling purposes and lies dormant until the read lock has been
浏览 4提问于2013-03-30得票数 0
回答已采纳
我正在尝试解释来自mongostat的结果。
我们正在运行一些压力测试，只在数据库上执行读取操作。mongostat的第一列证实了这一点，它报告了大约每秒6K的查询，0次插入，0次更新，0次删除。
尽管如此，"locked db“字段报告数据库被锁定的时间约为40%，其中约有130次排队读取，0次排队写入。
Mongo版本是2.2，运行在Linux机器集(带有2个节点+1个仲裁器的副本集)上。
你能告诉我发生了什么事吗？我认为锁是由于写造成的，但在我的测试场景中没有写。
浏览 0提问于2013-03-07得票数 0
1回答
我正在尝试构建一个层次锁定系统，以避免死锁。这意味着将代码分成层(或层)和每一层，以便只允许下一层中的锁。在同一级别内，您应该使用预定义的顺序进行锁定。这可以防止大多数死锁。类似这样的
对于互斥来说，这就像是一个护身符，但是对于读写锁，它就失败了。例如，如果我获取一个读锁，然后想要将其转换为写锁，这意味着我正在获取同一级别的一个新锁，这是这个算法所禁止的。
如何更改算法以适用于RW和互斥锁？有没有其他我应该考虑的算法？
PS:我正在编写C++程序，但这个问题实际上也是一个理论问题
浏览 1提问于2016-10-06得票数 0
我在C++中实现了一个systemd服务，该服务在系统启动时自动启动。该服务的目标是获取系统资源，并通过API访问它们。
其中一个资源是cpu负载。我实现了一个单独的线程，它在一个设置的间隔(每秒钟)中读取'/proc/stat‘中的信息，并从这些读数中同时计算cpu负载。当调用API时，读数存储在std::unordered_map<std::string, uint32_t>中，并从主程序读取值。
我读过，在不同线程中从同一个容器写入和读取时，应该使用读/写锁。这个假设正确吗？
如何实现这样的读/写锁？
映射的值是通过指定键：my_map['some_key&#
浏览 6提问于2022-09-28得票数 0
ReaderWriterLock类中的可升级读锁和写锁有什么不同？
根据MSDN的描述，只有一个线程可以进入可升级的读锁定。如果我没看错，我可能会忘记升级它，因为它和写锁是一样的。我遗漏了什么吗？
浏览 2提问于2012-05-22得票数 5
回答已采纳
我是多线程方面的新手，我很困惑，为什么在java同步.Also中需要读锁我理解写lock.In的用例，我们需要限制线程的读取器访问。假设我们在java中没有读锁，那么有什么问题呢？
浏览 1提问于2015-07-06得票数 1
4回答
我读到写锁是独占的，读锁是共享的，所以在读锁中的一段代码可以被多个线程访问。如果争用中的线程没有获得读锁，该怎么办？无论如何，他们将只读。另外，如果获取读锁的线程试图写入某些内容，该怎么办？
谢谢
浏览 5提问于2015-10-28得票数 4
1回答
我正在阅读关于ReadWriteLock的文档
读写锁是否会比使用互斥锁提高性能取决于与被修改相比数据被读取的频率、读和写操作的持续时间以及对数据的争用--即尝试同时读取或写入数据的线程数。
“互斥锁”是什么意思？这是否意味着我们一次只能执行一次操作(读或写)？例如，只是一个同步块。
浏览 0提问于2015-07-08得票数 1
回答已采纳
声明DB‘写贪婪’。这是我所理解的。但是，它没有说明锁对复制集中的第二个文件有什么作用。
以我的用例为例，每100次查询中大约有40次写到，其中我不需要在任何时候都有最新的文档。一个5-10秒的延迟对我来说是没问题的，那就是一个复制集中的第二次备份在主人后面的数量。现在，如果写锁锁定了母版和副本，那么我也被锁在了第二次文件的读取之外。
我想知道作者是否也会锁定第二次文件上的读取操作。
浏览 5提问于2013-09-07得票数 2
回答已采纳
2回答
读/写语义和对象语义的含义(简单地说)是什么？为什么下面的陈述是正确的？
借方/贷方写入银行账户，在读/写语义下被定义为冲突，而在对象语义下则不是。
浏览 5提问于2013-01-10得票数 0
回答已采纳
1回答
我正在研究Peter Pacheco一书中的pthread，他在书中提出了使用ptreads保护链表的解决方案：
pthread rwlock rdlock(&rwlock);
Member(value); //search
pthread rwlock unlock(&rwlock);
. . .
pthread rwlock wrlock(&rwlock);
Insert(value);
pthread rwlock unlock(&rwlock);
. . .
pthread rwlock wrlock(&rwlock);
Delete(va
浏览 1提问于2020-10-12得票数 0
1回答
锁转换更新锁
、、
我正在读你的书的第6章，事务处理的原理和更新锁的概念，对我来说并不是很清楚。基本上，我不清楚的是，当您尝试将更新锁升级为写锁时，不会发生锁定转换死锁。比方说，在更新锁到写锁的转换过程中不会发生死锁。那么你可以不使用下面的场景吗？
u1xr2xw1xw1zw2z。
u1x意味着事务1在x上有一个更新锁。
所以在上面的历史中，事务2在x上是在1之前，但在z上是在1之后。这不会违反可序列化吗？
如果你能帮我把这个弄清楚，我将不胜感激。
浏览 2提问于2013-03-03得票数 0
2回答
我想知道，与执行以下步骤相比，使用可升级的读锁有什么好处：
updateRelease 采取读锁检查条件看是否需要采取写锁发布读锁采取写锁<code>H 111</code>执行写锁<code>H 214</code><code>G 215</code>
与采取可升级的读锁相比，执行上述步骤的一个明显的缺点是，在步骤3和步骤4之间有一个时间窗口，其中另一个线程可以占用写锁。
除了这一优势，你还有什么其他的优势，采取可升级的读锁比我前面提到的步骤？
浏览 2提问于2012-01-09得票数 5
回答已采纳
目前，我在代码中使用一个来同步对树状结构的访问。这种结构很大，同时被多个线程读取，偶尔会修改它的小部分，所以它似乎很适合读-写成语。我了解到，对于这个特定的类，不能将读锁提升为写锁，因此根据Javadocs，必须在获得写锁之前释放读锁。我以前在不可重入的上下文中成功地使用了这种模式。
然而，我发现，如果不永远阻塞，就无法可靠地获得写锁。因为读锁是可重入的，我实际上是这样使用它的，所以简单的代码
lock.getReadLock().unlock();
lock.getWriteLock().lock()
如果我已经重新获得了重新锁定，就可以阻止。每次解锁的调用只会减少保持计数，只有当保持计数达
浏览 13提问于2009-01-21得票数 71
回答已采纳
我正在考虑使用Server 2012中的Server可用性组将我们的主数据库的报告卸载到通过可用性组保持同步的第二个只读服务器。
我的问题是，当我在只读服务器上运行大型报告时，如果在读/写版本上运行，通常会产生大量阻塞，锁会从只读服务器传回读/写服务器吗？还是锁只停留在只读服务器上，只导致阻塞等待同步的数据？
试图看看是否有一个只读服务器将解决一些问题，我有。
浏览 0提问于2013-01-16得票数 8
回答已采纳
1回答
其中system V有三种进程间通信方式: MessageQueue、SharedMemory、信号量。当两个进程同时在它上面读或写时，我是否应该使用一些同步，比如线程锁？
那么POSIX IPC呢？
浏览 3提问于2012-11-30得票数 0
var mu sync.RWMutex
go func() {
mu.RLock()
defer mu.RUnlock()
mu.RLock() // In my real scenario this second lock happened in a nested function.
defer mu.RUnlock()
// More code.
}()
mu.Lock()
mu.Unlock() // The goroutine above still hangs.
如果一个函数读-锁一个读/写互斥锁两次，而另一个函数写锁，然后写-un
浏览 0提问于2015-05-30得票数 4
回答已采纳
1回答
我正在用C++编写一个CPU密集型程序，它有几个线程需要访问一个共享的数据结构，因此需要锁定。为了最大化吞吐量，我希望将瓶颈保持在最低限度。看起来十有八九只需要读取数据结构，十分之一需要修改。
有没有一种方法可以让线程获得读或写锁，这样写锁就会阻塞所有东西，而读锁不会相互阻塞？
一个可移植的解决方案将是理想的，但是如果有一个用于Windows的解决方案和另一个用于Linux的解决方案，那将是可以的。
浏览 2提问于2012-08-31得票数 2
回答已采纳
我是这样做的
-- connection 1
START TRANSACTION;
LOCK TABLES [table_name] WRITE;
-- connection 2
START TRANSACTION;
SELECT * FROM [table_name]; -- waiting for table metadata lock
我不明白上面的情况。
我认为写锁不会阻止选择查询。
当我喜欢下面，
-- connection 1
START TRANSACTION;
UPDATE [table_name] SET [column = value] WHERE id = 1;
--
浏览 1提问于2019-01-23得票数 1
回答已采纳
在Java的实现锁中，没有办法将锁从读锁自动升级到写锁。例如，下面的代码片段失败 ReentrantReadWriteLock lock = new ...
lock.readLock().lock();
boolean mustWrite = false;
// do somestuff and determine you must instead write! :-O
if(mustWrite) {
lock.writeLock().lock();
writeSomeStuff();
lock.writeLock().unlock();
}
lock.read
浏览 4提问于2013-04-23得票数 2
2回答
当同步访问共享资源时，是否有理由不使用读/写锁而不是普通的互斥锁(这基本上只是一个写锁)，除了它具有比我可能需要的更多特性的哲学原因吗？
换句话说，如果我只是默认地将读/写锁作为我首选的同步结构，那么我是在朝自己开枪吗？
在我看来，总是选择读/写锁并相应地使用读/写锁的一个很好的理由是，我可以实现一些同步，如果有一天我将代码放到一个更高争用的环境中，那么我就不必再考虑它，同时获得更好的性能可伸缩性的好处。因此，假设它在没有实际成本的情况下有潜在的好处，那么一直使用它是有意义的。这有意义吗？
这是在一个资源有限的系统上，它可能更多的是一个性能问题。此外，我已经概括了这个问题，但我特别想到了Qt的
浏览 2提问于2016-09-14得票数 6
回答已采纳
从这个问题中，我认为所有线程都有相同的机会获得锁，而不管哪个是第一位的。
所以我编写了这段代码来测试它：
public static void main(String[] args) {
ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
final ReadLock readLock = lock.readLock();
final WriteLock writeLock = lock.writeLock();
// hold the write lock 3s at first
浏览 2提问于2011-11-01得票数 1
回答已采纳
2回答
我已经开始阅读有关单例会话bean和用于使用容器管理并发的注释的内容。与简单地使用'synchronized‘关键字相比，我看不出这有什么好处，所以我怀疑我遗漏了一些重要的东西。考虑O‘’Reilly的Rubinger & Burke的书"“中的这个例子：
@javax.ejb.Lock(javax.ejb.LockType.READ)
public String concurrentReadOnlyMethod(){...}
@javax.ejb.Lock(javax.ejb.LockType.WRITE)
public void allowOnlyOneWrite
浏览 0提问于2011-08-25得票数 9
回答已采纳
1回答
如果我有以下代码：
#include <boost/date_time.hpp>
#include <boost/thread.hpp>
boost::shared_mutex g_sharedMutex;
void reader()
{
boost::shared_lock<boost::shared_mutex> lock(g_sharedMutex);
boost::this_thread::sleep(boost::posix_time::seconds(10));
}
void makeReaders()
{
whil
浏览 0提问于2012-10-10得票数 1
回答已采纳
由于ConcurrentHashMap不能100%地保证写操作的安全一致性(即size())，所以使用ReentrantReadWriteLock(or它通过自定义派生类可以提高性能，对吗？
浏览 2提问于2013-05-03得票数 1
2回答
QReadWriteLock递归
、、、、
我在递归模式下使用QReadWriteLock。
这段代码本身并没有意义，但我从这里产生的问题是：
lock->lockForWrite();
lock->lockForRead();
lockForRead被阻塞了。注意，这是在递归模式。
在我看来，写是一个“高级”锁，它允许我读写受保护的数据，其中读锁只允许读取。
此外，我认为如果唯一的读取器是同一个请求写锁的读取器，则不应该阻止写锁。
我可以从qreadwritelock.cpp源代码中看到，并没有试图使它像我想要的那样工作。所以这不是一个bug，而是我发现缺少的一个特性。
我的问题是，应该允许这种递归吗？这种执行是否会产生任
浏览 3提问于2012-09-12得票数 6
2回答
如果有一项在表上有读取锁一分钟，那么其他项仍然可以不间断地读取同一表。
所以我可以有这个时间线
A使读取锁定一分钟B，C，D，E.还有更多的人没有问题地从那张桌子上读到
但假设T要求写锁。我得等..。似乎U都在等待T，尽管U只是要求读取锁，而T实际上还没有获得它的锁。
是否有可能禁用这种先入先出的优先级，并给予读锁比写锁更高的优先级？
编辑：，也许我可以在我的更新命令上设置某种低优先级的开关？我希望它是同步的(所以一个线程可以等到它完成，即使它是低优先级)。
浏览 1提问于2010-11-09得票数 5
回答已采纳
3回答
我在某个地方读到MongoDB持有db级写锁，这是否意味着当某人更新任何collection时，其他人不允许读取其他collection或它是如何工作的。另外，当有人向数据库写入任何内容时，MongoDB是如何获得写锁的，它的粒度是什么？
浏览 0提问于2013-09-11得票数 6
1回答
表级锁定保证了什么？
、、、
我有一个事务，它先对数据库执行一次读操作，然后执行一次写操作。如果我在MySQL中选择MyIsam作为我的数据库引擎，那么MyIsam的表级锁定机制是否可以保证，一旦事务开始读取，表就会被所有其他事务锁定？
我的意思是，如果有两个或多个事务，我希望它们按以下顺序进行：
R W R W R W R W R W...
但如果按以下顺序完成这些操作：
R R R R W W W W....
我的数据库进入了不一致的状态。这是have中对此特定表的特定要求。使表MYIsam足够了吗？如果没有，我还需要做什么？表级锁定是否仅用于写入？
浏览 1提问于2011-06-12得票数 1
回答已采纳
1回答
我的Java程序打开一个文件并缓慢地写入该文件。当操作完成后，程序将关闭该文件并将该文件移动到其在另一个目录中的最后休息位置。问题是，在运行操作时，同一个Java程序中的另一个线程将删除该文件。
Windows将不允许在文件打开时删除该文件。Linux允许文件在打开时被删除。在NFS文件系统中，Linux将重命名该文件，然后在文件关闭时自动删除该文件。如何防止文件打开时删除？
如何才能找到删除文件的内容？如何在删除文件的程序中获得Java线程的调用堆栈？
更改文件所有者将无法工作，因为同一进程中的另一个线程正在删除该文件。
程序正在主动地写入文件，因此删除文件上的写权限将无法工作。删除目录上的
浏览 0提问于2018-01-19得票数 3
回答已采纳
1回答
实现写优先R/W锁
、、、
我有一个互斥库，并且正在尝试实现一个写优先锁.我正在看这个例子：
我理解读优先锁，但我不理解写优先锁。有人能解释一下如何实现吗？
具体来说，我不明白这部分：
While w:
wait c, m
我也不明白w标志是通用的，还是每个进程只是一个不同的标志。我想是前者。
例如，这里我们看到了获取读锁的算法：
Lock m (blocking).
While (w or r > 0):
wait c, m
Set w to true.
Unlock m.
但是wait c, m是什么意思呢？这并不意味着要等待获得c和m的锁，因为我们已经在步骤1中锁定了m。
而且，对于Set w to
浏览 4提问于2018-06-29得票数 5
回答已采纳
下面的示例代码(请参阅下面的代码)是通过线程执行的：
A: rd-lock
B: wr-lock (waiting)
A: rd-lock (recursive)
A: rd-unlock (recursive)
A: rd-unlock
B: wr-locked (wake after wait)
B: wr-unlock.
基本上读锁是递归的。它是POSIX标准所要求的(要求读锁是递归的，但不是为写锁指定的)。这在Linux、FreeBSD、Solaris上有效，但在达尔文/Mac上不起作用。
下面的示例在Linux上提供了以下输出：
read locking
read locked
wr
浏览 7提问于2012-01-10得票数 1
1回答
情况是:多核处理器上的计划任务(带有可运行的任务)必须通过实时系统上的共享全局变量相互通信。多个运行表同时更新相同的全局值。此值将存储在缓冲区中。为了确保正确的值可供使用，我正在考虑使用读-修改-写类作为缓冲区，以避免互斥，锁等。
我想知道你对它的看法和评论，例如在实时通信系统中使用缓冲区和读-修改-写技术，工作吗？或者在这种情况下是否有更好的技术可供使用？
请发表意见。
浏览 7提问于2014-05-08得票数 1
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
腾讯会议
实时音视频活动推荐
腾讯云开发者
