在Firebase中使用Mutex锁定文档，同时在扩展时避免多次重试
。
在Firebase中，可以使用事务（Transaction）来实现对文档的锁定和扩展时的重试机制。事务是一种原子操作，可以确保在多个客户端同时修改同一文档时的数据一致性。
Mutex（互斥锁）是一种同步机制，用于保护共享资源，防止多个线程同时访问和修改该资源。在Firebase中，可以使用事务来模拟Mutex的功能，确保在对文档进行修改时，只有一个客户端能够成功修改。
下面是在Firebase中使用Mutex锁定文档的步骤：
- 定义一个互斥锁字段（例如，"isLocked"）作为文档的一部分，用于表示该文档是否已被锁定。
- 在需要锁定文档的地方，使用事务来更新文档。在事务中，首先检查互斥锁字段的值是否为false，表示该文档未被锁定。如果是，则将互斥锁字段的值设置为true，表示锁定该文档，并进行其他需要的操作。如果不是，则表示该文档已被锁定，事务会自动重试，直到成功为止。
- 在完成对文档的操作后，释放互斥锁，将互斥锁字段的值设置为false，表示该文档已解锁。
使用Mutex锁定文档的优势是确保在多个客户端同时修改同一文档时的数据一致性，避免冲突和竞争条件的发生。
应用场景：
- 在多用户协作编辑的应用中，确保同一文档只能被一个用户编辑。
- 在订单处理系统中，确保同一订单只能被一个用户处理。
- 在实时聊天应用中，确保同一消息只能被一个用户发送。
推荐的腾讯云相关产品和产品介绍链接地址：
- 腾讯云数据库MongoDB：https://cloud.tencent.com/product/mongodb
- 腾讯云云函数（Serverless）：https://cloud.tencent.com/product/scf
- 腾讯云消息队列CMQ：https://cloud.tencent.com/product/cmq
- 腾讯云云开发：https://cloud.tencent.com/product/tcb
请注意，以上推荐的腾讯云产品仅供参考，具体选择应根据实际需求和情况进行评估和决策。
相关·内容
2回答
如何解决多互斥中的死锁
、、、
我有一个需要锁定多个互斥的代码。
void AttackAoeRequest(Player* attacker, int range)
{
std::lock_guard<std::mutex> lk_attacker(attacker->mtx);
if (attacker->isInVehicle)
{
return;
}
//there are a lot of code that need to check before the loop, and these code need to access a
浏览 1提问于2022-02-04得票数 0
3回答
我有一个线程服务器，可以添加/追加/读取文件，并将数据中继到客户端。
如果要添加文件，则没有其他线程可以追加/读取该文件。如果要追加文件，则没有线程可以追加/读取该文件。如果正在读取文件，则无法向其追加任何其他线程。但是，如果正在读取一个文件，则其他文件可以读取它。
目前，我有一个互斥系统，可以做到这一点，但它不允许多次读取。
为了解决这个问题，在read方法中，我将更改：
pthread_mutex_lock(&(fm->mutex));//LOCK
//do some things`
...
pthread_mutex_unlock(&(fm->mutex));
浏览 0提问于2014-11-19得票数 0
回答已采纳
1回答
c++中的几个互斥锁
、、、
在许多地方都有使用std：：defer_lock的建议：
{
std::unique_lock<std::mutex> lk1(mutex1, std::defer_lock);
std::unique_lock<std::mutex> lk2(mutex2, std::defer_lock);
std::lock(lk1, lk2);
//Do some stuff
}
但是，如果我不使用std::defer_lock，并尝试简单地这样做呢：
{
std::unique_lock<std::mutex> lk1(mu
浏览 4提问于2017-05-31得票数 0
我相信这个问题会被问很多次，但我想澄清这个概念。
最近，当两个线程在两个不同的函数中访问相同的列表时，我遇到了一个bug。如果我没有正确的锁定，在什么情况下会导致问题？尽管我在第二个函数中有一个锁，并且这两个线程没有关联，但它们正在操作相同的列表。一个是添加，另一个是用空列表交换。在什么情况下才会有例外呢？请帮帮忙。
PseudoCode：
List<SomeClass> list=new List<SomeClass>();
object mutex=new object();
线程1访问此函数并修改列表：
public void Manipulate()
{
浏览 2提问于2013-10-18得票数 2
我试图通过使用std::lock对象来阻止对DLL初始化函数的多次调用。
当在独立程序上使用这样的程序时，工作如下：
#include <mutex>
std::mutex mtx;
void main(){
mtx.lock();
(...)
mtx.unlock()
}
在DLL上调用时，这种完全相同的代码无法通过mtx.lock()。
BOOL APIENTRY DllMain(HANDLE hModule,
DWORD ul_reason_for_call,
LPVOID lpReserved)
{
f_Init(VERSION_ID
浏览 0提问于2014-07-07得票数 3
我在SAP代理日志中看到以下错误，
(5538F3C3.0122-3154:pthread_mutex_unlock.c,44,"pthread_mutex_unlock") errno EAGAIN
并且在该代理进入无响应状态之后。这是pthread_mutex_unlock()返回错误代码EAGAIN的正确行为吗？如果是这样，任何人都可以帮助我在这种情况下获得错误处理的洞察力。
浏览 1提问于2015-05-06得票数 0
3回答
线程导致意外崩溃
、、
我不知道这里有什么问题，但当我在OS上运行我的代码时，它工作得很好，但在Linux上我的程序将无法运行。
下面是我的代码：
Thread() {
- some other code -
randLane1 = rand() % 16;
randLane2 = rand() % 16;
while(randLane1 == randLane2) {
randLane2 = rand() % 16;
}
浏览 0提问于2015-11-10得票数 0
1回答
时间间隔(线程)
、、
我必须模拟轮盘赌游戏，因为我们的老师给了我们一个练习(没有评分)。它必须是一个多线程客户端-服务器应用程序。我正在设计服务器(客户端非常简单，它只需要发送赌注的请求)，但是我被卡住了。我有两个线程函数，croupier:这个函数每隔N秒拉出一次数字(在命令行中指定)玩家:这个函数读取croupier拉出的数字并将赌注插入到共享列表中。每个玩家可以下注一次或多次。
我的问题是:我可以使用cond_timedwait来模拟两个数字被拉出之间的时间间隔吗？有没有其他方法可以做到这一点？
void *croupier(void *arg) {
struct timespec cond_time;
t
浏览 4提问于2010-11-10得票数 0
2回答
我在问一个关于多线程的问题。
假设我有两个全局向量，
std::vector<MyClass1*> vec1
和
std::vector<MyClass2*> vec2.
此外，我总共有4个线程可以访问vec1和vec2。我可以按以下方式编写代码吗？
void thread_func()
// this is the function that will be executed by a thread
{
MyClass1* myObj1 = someFunction1();
MyClass2* myObj2 = someFunction2();
浏览 0提问于2015-05-17得票数 7
void transfer(bank_account &from, bank_account &to, int amount)
{
// lock both mutexes without deadlock
std::lock(from.m, to.m);
// make sure both already-locked mutexes are unlocked at the end of scope
std::lock_guard<std::mutex> lock1(from.m, std::adopt_lock);
st
浏览 0提问于2018-08-17得票数 3
回答已采纳
我正在使用Firebase Admin SDK和Cloud Functions。该函数对多个Firestore集合执行多次写入，这些集合需要保持一致。 现在，我不确定如果一个有效的操作(比如写入文档)失败了(可能是通过宇宙辐射或类似的不太可能的东西)，Firestore操作是如何表现的。 该操作是否立即返回错误，或者是否存在某种重试或纠错机制？ 也许这是一个愚蠢的问题，与SDK本身没有任何关系。
浏览 10提问于2019-04-18得票数 0
回答已采纳
如果我有两个关键部分，并设置两个相应的互斥来保护它们。(我认为有必要精确控制何时锁定，因为它们在不同的时间和场景中使用，Q1：真的是这样吗？)例如：
bool a;//ignore atomic_bool, because in actual, the data structure is more complex
mutex mut_a;//for threadsafe of a
bool b;
mutex mut_b;//for threadsafe of b
我需要实现这样的逻辑：
if (lock_guard<mutex> lck(mut_a);a) { do somethi
浏览 8提问于2022-06-15得票数 0
回答已采纳
2回答
使用多个互斥锁
、、、
我有一个很大的树结构，有几个线程同时在上面工作。理想情况下，我希望每个单元都有一个单独的互斥锁。
我在bits/pthreadtypes.h中查看了pthread_mutex_t的定义，它相当短，所以在我的例子中，内存使用应该不是问题。
然而，当仅对8个线程使用多个(比方说几千个)不同的pthread_mutex_t时，是否存在性能损失？
浏览 2提问于2010-05-05得票数 10
回答已采纳
我需要在函数中锁定std::map和两个boost::multimaps的操作，因为我们有线程试图访问函数(以及映射)。
我计划使用一个"std::mutex mutex_var“来保护那些操作它们的函数中的变量。所以我有"std::mutex mutex_var“变量。我混淆了函数开头使用"mutex_var.lock()“和函数末尾使用"mutex_var.unlock()”--只是在函数的开头使用std::lock_guard？
为了清晰起见，函数所做的就是在互斥体上添加内容。我也明白，我们不需要保护所有试图查询地图的地方(因为它只是一个读取操作)。
请让
浏览 4提问于2016-11-15得票数 0
3回答
我问这个问题是因为我找到的所有互斥文档都是处理单个函数的，我认为我的情况非常常见。
我的问题是，下面的代码是否不仅会阻止func1() 或 func2()并行执行多次，还会不会阻止func1() 和 func2()同时执行？
#include <mutex>
std::mutex my_mutex;
void func1() {
my_mutex.lock();
// do something ...
my_mutex.unlock();
}
void func2() {
my_mutex.lock();
// do something
浏览 0提问于2017-03-13得票数 5
回答已采纳
以下代码挂起是因为需要多次调用才能获得非递归互斥体：
#include <pthread.h>
class Lock
{
public:
Lock( pthread_mutex_t& mutex )
: mutex_( mutex )
{
pthread_mutex_lock( &mutex_ );
}
~Lock()
{
pthread_mutex_unlock( &mutex_ );
}
private:
pthread_mutex_t& mutex_;
};
class Foo
{
浏览 5提问于2017-12-31得票数 1
回答已采纳
看起来，在c++17中提供了我想要的功能，但是我现在被绑定到了c++11。
目前，当我们使用同一个互斥体多次调用它时，我看到了guard_lock的死锁问题。scoped_lock是否对多个呼叫(即重接？)进行保护？在c++11 w/ lock_guard中有这样做的最佳实践吗？
mutex lockingMutex;
void get(string s)
{
lock_guard<mutex> lock(lockingMutex);
if (isPresent(s))
{
//....
}
}
bool isPresent(st
浏览 0提问于2018-10-25得票数 1
回答已采纳
我已经写了一个简单的pthread代码，
#include <pthread.h>
#include <stdio.h>
#include <math.h>
#define ITERATIONS 500
// A shared mutex
pthread_mutex_t mutex;
int target;
void* opponent(void *arg)
{
int i;
printf("opp, before for target=%d\n", target);
pthread_mutex_lock(&mute
浏览 0提问于2013-04-04得票数 3
回答已采纳
3回答
锁定多个互斥锁
、、
我想知道是否可以同时锁定多个互斥锁，例如：
Mutex1.Lock();
{
Mutex2.Lock();
{
// Code locked by mutex 1 and 2.
}
Mutex2.Unlock();
// Code locked by mutex 1.
}
Mutex1.Unlock();
在某些情况下，它将非常有用。谢谢。
浏览 4提问于2012-11-21得票数 22
回答已采纳
1回答
同步队列包装器C++11
、、、
我正在尝试编写一个SynchronizedQueue包装器类，以便为底层标准std::queue提供一个简单的同步接口。
你能不能回顾一下，让我知道你是否发现了什么缺陷和改进？
太多的互斥/锁？我希望使用条件变量来等待，而不是使用互斥变量来进行push & pop通知。
任何见解都是非常感谢的，因为我很少写多线程程序。
#pragma once
#include <mutex>
#include <condition_variable>
#include <queue>
#include <cstdint>
template&l
浏览 0提问于2017-11-17得票数 1
回答已采纳
当同一个线程多次锁定它时，std::recursive_mutex不会死锁。
当多个线程多次锁定它时，它会死锁吗？
浏览 0提问于2018-04-24得票数 1
回答已采纳
1回答
我有一个QML应用程序与用户输入。有一个计时器，它监听服务器的工作指令，然后将所有信息插入到application.Also用户的SQLite数据库中，对数据进行更改(更新、删除等)在SQLite中。我的问题是，如何防止对SQLite表的多次操作。只有一个操作必须在SQLite上生效(select、delete、insert、update....)我不知道，但是，Mutex.lock structure可以用来做这个吗？还是SQLite上的多个操作有问题？
浏览 1提问于2016-05-23得票数 1
这是g_cond_wait()的Glib文档中的一个示例。
gpointer current_data = NULL;
GMutex data_mutex;
GCond data_cond;
void push_data (gpointer data)
{
g_mutex_lock (&data_mutex); // (3)
current_data = data;
g_cond_signal (&data_cond);
g_mutex_unlock (&data_mutex); // (4)
}
gpointer pop_data (void)
{
浏览 8提问于2015-06-16得票数 6
回答已采纳
3回答
我正在以递增的顺序获取一些资源。哪个版本更好？有人告诉我，#2会导致需要更高编号资源的线程匮乏。这是真的吗？如果是这样的话，如何和为什么？
a[] sorted array
1.
for(int i = 1; i < N; ++i) {
lock(mutex)
while(!resource_available[a[i]]) {
pthread_cond_wait(&cond_w[a[i]], &mutex);
}
resource_available[a[i]] = 0;
unlock(mutex)
}
2.
lock(mutex)
for
浏览 0提问于2011-01-24得票数 5
回答已采纳
4回答
在以下代码段中是否可能出现死锁：
void f()
{
{
std::lock_guard <std::mutex> inner (lock1);
// do something and conditionally return
}
std::lock_guard <std::mutex> outer (lock2);
// do something
}
IOW，如果多个线程调用此函数，会出现死锁吗？
我不太确定，所以任何帮助都是非常感谢的。
浏览 3提问于2019-11-15得票数 1
回答已采纳
1回答
借用并修改它以使用复制和交换，这个op=线程安全吗？
struct A {
A() = default;
A(A const &x); // Assume implements correct locking and copying.
A& operator=(A x) {
std::lock_guard<std::mutex> lock_data (_mut);
using std::swap;
swap(_data, x._data);
return *this;
}
private:
mutable s
浏览 0提问于2011-02-21得票数 6
回答已采纳
2回答
假设您有一个大函数，它在内部锁定/解锁互斥体，并且希望将该函数分解为较小的函数：
#include <pthread.h>
class MyClass : public Uncopyable
{
public:
MyClass() : m_mutexBuffer(PTHREAD_MUTEX_INITIALIZER), m_vecBuffer() {}
~MyClass() {}
void MyBigFunction()
{
pthread_mutex_lock(&m_mutexBuffer);
if (m
浏览 4提问于2013-09-16得票数 4
回答已采纳
1回答
在线程中使用不同的互斥锁
、、、
我已经编写了以下程序来在POSIX中实现两个线程。有一个全局共享变量sum，它由两个不同的线程同时访问。在访问共享变量时，我在每个线程中使用了互斥锁和解锁。我有个问题。在这里，我在两个线程中使用了samed互斥锁(pthread_mutex_lock(&mutex))。如果我在thread1的线程(比如pthread_mutex_lock(&mutex))和thread2的pthread_mutex_lock(&mutex1)线程中使用两个不同的互斥锁和解锁，会发生什么？我已经注释掉了代码中的混乱之处。
我的示例代码片段：
#include<stdio.h>
浏览 3提问于2015-10-18得票数 3
4回答
C++中的线程间通信
、、、、
我有两个线程(应用程序主线程和另一个线程)。我使用OpenGL绘制一些东西，我使用OpenGL键盘和鼠标回调。当我调用glutMainLoop()时，由于必须在后台进行一些计算，所以我创建了另一个线程。现在，OpenGL回调将向另一个具有关键部分的线程发送一些数据(例如，按下鼠标/键的x，y位置)。虽然关键部分正在运行，但不应该接受任何消息，但我不想删除这些消息，我希望在关键部分之后处理它们。非OpenGL类如下所示：
void run()
{
for (;;) {
int currentTime = now();
if (now() - previou
浏览 7提问于2010-11-20得票数 3
回答已采纳
在关于QMutex的Qt文档中，有这样的说法：
(.)当您在线程中调用lock()时，试图在同一个位置调用lock()的其他线程将被阻塞，直到获得锁调用的线程发出unlock()。lock()的一个非阻塞替代方案是tryLock()。(...)
我已经多次使用这个代码了：
QMutex mutex;<br>
while( !mutex.tryLock() );
有人能解释一下这个tryLock()方法是如何构建的，while()循环不会挂起整个程序吗？
两个线程共享一个QMutex并充当一个通信FIFO --当一个线程发送数据，而另一个数据被调度到第二个线程时，该线程正在等待第
浏览 3提问于2012-04-13得票数 2
回答已采纳
2回答
#include <iostream>
#include <mutex>
#include <thread>
using namespace std;
mutex m1;
mutex m2;
template<typename T>
void foo(const T& t){
m1.lock();
cout << t << '\n';
m1.unlock();
}
int main(){
thread t1{foo<string>,"lock
浏览 5提问于2016-05-01得票数 0
回答已采纳
1回答
简单C++线程池
、、、
我使用一些C++11特性编写了一个极简的线程池。到目前为止，我已经在两个项目中使用了它，并且运行得很好，但是当我在我的笔记本上运行代码时，我相信我的线程池可能进入某种死锁状态--偶尔CPU活动会下降到几乎为零，程序会挂起。
你对密码有什么看法？
我的头文件：
#include <utils/Uncopyable.h>
#include <vector>
#include <queue>
#include <thread>
#include <mutex>
#include <atomic>
#include <con
浏览 0提问于2015-02-02得票数 9
回答已采纳
3回答
类的部分互斥
、、、、
可以在类的部分上使用互斥对象吗？
比如：
class A{
int a;
int b;
boost::mutex Mutex_for_a;
boost::mutex Mutex_for_b;
}
然后使用正确的互斥来执行正确的操作。我知道这在技术上是可能的，但我不知道它是否会导致问题。
浏览 2提问于2018-05-15得票数 2
回答已采纳
2回答
检测线程安全链表中的死锁
、、、
我最近完成了一个实现线程安全的单链表的家庭作业，它将元素锁定在hand - over方法中，这意味着列表中的每个元素都有一个锁。我实现了所有的函数，并对它们进行了测试，而不必处理有问题的线程情况，它们都起作用了，但我想测试是否会出现死锁或饥饿的情况，但我不知道如何做到这一点，通过查看我的代码，我能知道是否会出现死锁或饥饿吗？我也不确定代码中是否需要这么多的锁定和解锁。请注意，在每个函数中，我锁定了一个元素及其后继元素，这足够了吗？如果我的代码容易出现死锁、饥饿或任何其他问题，有什么帮助或建议吗？我将在下面发布我的代码。提前谢谢。
concurrent_list.h：
typedef struc
浏览 0提问于2019-06-21得票数 2
4回答
考虑以下两个宏：
#define PNORM( v, s, ... ) { \
if( VERBOSITY_CHECK( v ) ) { \
if( ( errno = pthread_mutex_lock(&server.output_mutex) ) ) { \
PERROR_LOCKFREE( normal, "\tpthread_mutex_lock failed on output_mutex.\r\n" ) ; \
} \
fprintf( stdout, s, ## __VA_ARGS__ ) ; \
ff
浏览 0提问于2010-11-05得票数 10
回答已采纳
1回答
Firebase并发读/写
、、、、
我使用Firebase事务来获取比较值，然后更新集合中文档的值。
但是当我使用相同的数据并同时发送查询时，它们都读取了相同的值，所以我对两者都通过了检查，最后我得到了一个坏的结果。该字段递减两次。
我的事务是：
let docRef = db.collection('X').doc('SF');
let reduceValue = 20;
let transaction = db.runTransaction(t => {
return t.get(docRef)
.then(doc => {
let value = do
浏览 1提问于2020-06-05得票数 0
2回答
我设计了一个C++11线程死锁。这是使用两个具有多个线程池的独立函数来实现的。如何修正此示例以避免死锁？我认为这个解决方案与锁程序的顺序一致有关。
#include <thread>
#include <mutex>
#include <iostream>
std::mutex kettle;
std::mutex tap;
#define THREAD_POOL 8
void kettle_tap(){
std::cout << "Locking kettle in " << std::this_th
浏览 2提问于2014-09-04得票数 4
回答已采纳
1回答
在每一篇关于互斥的教程中，互斥被描述为一种防止多个线程同时访问相同资源的方法。但这些资源是什么。我知道资源可以是很多东西，比如变量，但是如何定义那些不应该同时由另一个线程使用的变量呢？互斥锁如何知道要“锁定”哪些变量？我不明白编译器在执行代码之前如何知道Mutex在函数mutex.lock和mutex.release之间应该锁定什么。
浏览 2提问于2022-09-29得票数 3
2回答
我正在开发一个简单的银行系统。我实现的一个功能是doTransaction.。简化后，如下所示：
#include <vector>
#include <mutex>
const int N = 1000;
int accounts[N];
std::vector<std::mutex> mutexes(N);
int doTransaction(int from, int to, int amount) {
std::lock_guard<std::mutex> lock_from(mutexes[from]);
std::
浏览 3提问于2020-12-12得票数 0
我试图设计一个作为数据持有者的类(包含很多成员、getter和setter)。该类将用于程序中的多个其他线程，并可用于数据交换，即一个组件更新对象，其他组件在需要时可以读出更改的值。
即使一个成员的写入(通过调用setter)只能同时发生，但是getter可以在多个位置被调用。
下面是类代码。
#include <mutex>
class DataType{};
class DataStore
{
private:
mutable std::mutex _mtx;
DataType _member;
// different other member!
浏览 6提问于2021-12-09得票数 3
2回答
Boost Mutex作用域锁定
、、、、
我通读了一篇关于drdobbs.com的Boost Mutex教程，发现了这段代码：
#include <boost/thread/thread.hpp>
#include <boost/thread/mutex.hpp>
#include <boost/bind.hpp>
#include <iostream>
boost::mutex io_mutex;
void count(int id)
{
for (int i = 0; i < 10; ++i)
{
boost::mutex::scoped_lock
浏览 4提问于2013-06-02得票数 18
回答已采纳
我有一个关于bool：：tryLock(Int timeout)方法的问题。我注意到，在不同版本(即5.15和6.4)中，对此方法的描述略有不同。
文件中的表示：“如果这个互斥互斥是递归互斥，则允许在同一个线程上多次调用此函数。如果这个互斥互斥是非递归互斥，则该函数在试图递归锁定互斥对象时总是返回false。”
在6.4ver.中的中，文档说“从同一个线程多次在同一个互斥体上调用这个函数将导致死锁。”
我现在使用的是QT5.13.2版本。在同一个线程上多次调用tryLock可以吗？或者是5.15元的文件。是不正确的。谢谢!
参考文献：
Qt 6.4.1ver.：
我给QT团队发了一封邮件，但还
浏览 10提问于2022-11-27得票数 1
5回答
在线程锁定互斥锁之前，我想检查它是否已经对互斥锁有了锁，所以我无法执行这个。
Acquire mutex
Acquire mutex
// do something here
Release mutex
// still has mutex lock at this point!!
我知道我可以在这里喝一杯，但我想知道是否有什么东西已经存在了。
谢谢。
浏览 11提问于2012-02-01得票数 0
回答已采纳
我有一个很大的Firebase文档集合，我将其视为堆栈数组，其中第一个元素被读取并从堆栈中删除。我的主要问题是，我有超过1000个连接试图访问该集合，并且我在接收相同文档的连接时遇到问题。为了防止重复的结果，我求助于使用Mutex，正如下面的文章所引用的那样。
在从集合中删除文档之前，我使用了一个Mutex来锁定每个文档。我使用事务来确保互斥锁所有者不会被其他连接覆盖，或者检查文档是否还没有被删除。
我在这个解决方案中遇到的问题是，随着规模的扩大，越来越多的连接正在为检索互斥锁而争斗。每个连接都会花费很长时间重试，直到成功锁定文档为止。避免长时间重试将允许更快的响应时间和更少的读取。
因此，
浏览 17提问于2019-11-26得票数 2
4回答
为什么读/写锁需要锁？
、、、
我有一个读写锁的实现，如下所示。请注意，在函数的开头，有一个pthread_mutex_lock调用。如果它使用了一次pthread_mutex_lock，那么使用读/写锁有什么好处呢？它比简单地使用pthread_mutex_lock有什么好处呢？
int pthread_rwlock_rlock_np(pthread_rwlock_t *rwlock)
{
pthread_mutex_lock(&(rwlock->mutex));
rwlock->r_waiting++;
while (rwlock->r_wait > 0)
浏览 1提问于2012-06-22得票数 2
回答已采纳
1回答
跳过列表中的细粒度锁定
、、、
我正在尝试使用细粒度的锁定机制在c中实现基于锁的skiplist。在运行代码时，应用的锁定机制似乎是粗粒度的。我使用在节点结构中定义的pthread_mutex_t锁变量在前面的节点中放置了锁，以便插入，并在使用后释放它们。整个列表没有被锁定，只有节点被锁定，但它似乎仍然实现了粗粒度的锁定机制。下面提供了完成锁定机制的代码片段。实现是错误的吗？
for(level = 0; valid && (level <=topLevel); level++){
pred = preds[level];
succ = succs[lev
浏览 2提问于2014-12-04得票数 0
2回答
想象一下，我有以下几点：
struct A {
std::vector<int> _vect;
std::mutex _mutex;
void f () {
std::thread t1(&A::work, this);
std::thread t2(&A::work, this);
t1.join();
t2.join();
}
void work () {
std::vector<int> cvect;
浏览 3提问于2016-03-15得票数 1
回答已采纳
在我的Linux应用程序中，有两个线程都试图使用相同的UDP客户端套接字发送UDP广播数据包(大约50-500字节)。他们大约每2-3秒做一次。在本例中，使用"send(...)“子句，我可以将pthread_mutex_lock或pthread_spin_lock。理论上说，如果它是一个非常小的操作，pthread_spin_lock会更有效率(尽管在这一小段时间内CPU消耗很高)。但是如果它是一个更大的操作，那么pthread_mutex_lock更好。
发送UDP数据包是否被认为“足够小”来保证使用pthread_spin_lock，或者我应该仍然坚持使用pthread_mute
浏览 3提问于2013-02-03得票数 1
回答已采纳
3回答
我有以下代码：
#include <chrono>
#include <iostream>
#include <mutex>
#include <thread>
int shared_var {0};
std::mutex shared_mutex;
void task_1()
{
while (true)
{
shared_mutex.lock();
const auto temp = shared_var;
std::this_thread::sleep_for(std::c
浏览 3提问于2022-05-05得票数 0
回答已采纳
我有一个由线程1，2，3，4执行的函数.一旦thread1访问了该函数，我就使用thread_cond等待其他线程。一旦thread1完成了它的工作，我就将thread_signal发送到相同的cond。Thread2正在执行该函数。但是，在它完成执行之后，其他线程将无法访问该函数。
请帮帮我
#include<stdio.h>
#include<unistd.h>
#include<pthread.h>
int limit = 0;
pthread_mutex_t mutex[100];
pthread_cond_t cond[100];
pthread
浏览 3提问于2017-10-03得票数 1
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
实时音视频
即时通信 IM活动推荐
腾讯云开发者
