如何在互斥锁保护的结构中找到数据竞争？
在互斥锁保护的结构中找到数据竞争可以通过以下步骤进行：
- 理解互斥锁的作用：互斥锁是一种同步机制，用于保护共享资源，确保在任意时刻只有一个线程可以访问共享资源，从而避免数据竞争和不一致性。
- 审查代码：仔细检查代码，特别是涉及共享资源的部分。查找所有使用互斥锁的地方，包括锁的获取和释放操作。
- 确定共享资源：确定哪些数据是共享资源，即多个线程可能同时访问和修改的数据。
- 检查锁的使用：确保在访问共享资源之前获取锁，在完成访问后释放锁。检查是否存在遗漏获取或释放锁的情况。
- 分析竞争条件：仔细分析代码，找出可能导致数据竞争的情况。例如，多个线程同时读取和写入共享资源，或者多个线程同时修改共享资源的不同部分。
- 使用工具进行静态分析：可以使用静态分析工具来帮助检测潜在的数据竞争问题。这些工具可以分析代码并发现可能存在的竞争条件。
- 运行时检测：在代码中插入适当的日志或断言语句，以便在运行时检测到数据竞争。这些语句可以帮助捕获并报告竞争条件的发生。
- 并发测试：设计并发测试用例，模拟多个线程同时访问共享资源的情况。观察测试结果，查看是否存在数据竞争的迹象，如数据不一致或程序崩溃。
总结：通过仔细审查代码、分析竞争条件、使用工具进行静态分析、插入运行时检测语句以及进行并发测试，可以帮助找到互斥锁保护的结构中的数据竞争问题。及时解决这些问题可以确保代码的正确性和可靠性。
腾讯云相关产品和产品介绍链接地址：
- 云服务器（ECS）：https://cloud.tencent.com/product/cvm
- 云数据库 MySQL 版（CDB）：https://cloud.tencent.com/product/cdb
- 云原生容器服务（TKE）：https://cloud.tencent.com/product/tke
- 云存储（COS）：https://cloud.tencent.com/product/cos
- 人工智能平台（AI Lab）：https://cloud.tencent.com/product/ailab
- 物联网开发平台（IoT Explorer）：https://cloud.tencent.com/product/explorer
- 移动推送服务（信鸽）：https://cloud.tencent.com/product/tpns
相关·内容
假设我有一个名为的结构
struct _Visitors{
int totalNum;
map<uintptr_t, Visitor*> visitorMap;
};
请注意，访问者是一个c++类
然后，我声明一个指向结构_visitors实例的指针，即
struct _Visitors* pVisitors = NULL;
现在我有三个线程:一个主线程t1，两个工作线程t2和t3。
t1是这样的：
pVisitors =新_visitors()；
t2是这样的：
while(true){
if a new visitor v enters
浏览 1提问于2012-12-21得票数 0
我对线程有些陌生，我正试图了解它在C++11中的工作原理。
#include <list>
#include <mutex>
#include <algorithm>
std::list<int> some_list; // A data structure accessed by multiple threads
std::mutex some_mutex; // This lock will prevent concurrent access to the shared data structure
void
add_to_list(
浏览 5提问于2013-02-02得票数 10
我是c++的新手，从事的应该是非常基本的文件读取，然后处理数据功能，我一直被困在至少能够为另一个人提供线程上的“状态”，以便数据可以被使用。这可能是我忽略的一些非常基础的东西--可以使用一些在c++中使用pthread的洞察力。
下面是一些基本的提取代码，功能正常，读取文件并提供要处理的数据。另一个处理数据的线程需要知道这个线程的状态。最好的策略是什么？我试图通过函数从另一个线程请求线程的状态，但收到了不正确的响应。
Reader::Reader(){
_threadId = 1;
_msg = NONE; // enum NONE, READ, STOP
acti
浏览 0提问于2012-12-12得票数 1
回答已采纳
1回答
我在Linux上用C开发的代码有问题。
我有一个类似这样的结构：
typedef struct _my_sem {
unsigned int valid;
pthread_mutex_t m;
} my_sem;
以及以下功能(不报告错误管理)：
void my_sem_init(my_sem *s);
void my_sem_destroy(my_sem *s);
void my_sem_lock(my_sem *s);
void my_sem_unlock(my_sem *s);
void my_sem_init(my_sem *s)
{
pthread_mut
浏览 0提问于2016-10-12得票数 0
1回答
我正在构建一个基于PCL的应用程序，它使用velodyne的默认PCL抓取器代码，可以看到。
当我在调试模式下构建我的应用程序时，它按照预期工作，但在发布构建中，云被跳过了，我松开了一两个云。我缩小到一个事实，即互斥锁有一些我没有经验的问题。
// Retrieved Point Cloud Callback Function
boost::mutex mutex;
boost::function<void(const pcl::PointCloud<PointType>::ConstPtr&)> function =[&cloud, &mute
浏览 21提问于2018-04-30得票数 2
我写了一个学习c++线程的测试项目，但我的程序中发生了一些错误。
该代码是一个例子，一个类提供了一个函数，可以将数据添加到容器中，数据将在线程中打印，打印后的数据将从容器中删除。
这就是代码：
#include <mutex>
#include <thread>
#include <vector>
#include <algorithm>
#include <iostream>
using namespace std;
class Manager
{
public:
Manager()
{
cons
浏览 1提问于2018-08-01得票数 1
回答已采纳
3回答
条件变量与互斥
、、
有点困惑！如果我们看下面的场景，问题可能是什么:我的目标是理解条件变量和互斥变量的混合。
T1
LOCK { MUTEX } 检查变量如果未设置，则等待条件变量解锁{MUTEX}转到1
T2
修改变量；信号条件变量
在第2步和第3步之间可能有比赛条件，因此我们使用MUTEX。我不明白的是cond + mutex的基本概念。
浏览 4提问于2011-08-29得票数 3
回答已采纳
2回答
我使用自旋锁(线程锁)，通常在锁定代码部分中使用O(1)列表元素访问/删除。
我之所以这样说，通常是因为99.9%的情况下，代码不会遍历列表(其中可能包含1000+元素)。
代码通常只根据list元素提示指针提取一个元素，然后执行几个if分支来修改引用的提示元素；不过，它应该是对内存的非连续访问。
使用自旋锁是个好主意，还是我应该移到互斥对象上？
我的目标是最大限度的性能，不关心CPU (超过)在这个上下文中的使用。
干杯
浏览 4提问于2013-02-23得票数 2
我使用4个go例程为一个结构实例分配不同的成员变量。每个成员变量只能由一个go例程访问。 访问struct实例时需要添加互斥锁吗？ 我不确定这4个go例程是否访问相同的内存。我觉得我应该是因为他们所有人都访问持有者。 这段代码演示了我正在做的事情。 package main
import (
"fmt"
"sync"
)
func main() {
var wg sync.WaitGroup
var res Response
var mu sync.Mutex
wg.Add(1)
go func(
浏览 21提问于2019-05-25得票数 0
回答已采纳
我让线程1执行以下代码：
unique_lock<mutex> ul(m);
while(condition == true)
cv.wait(ul);
和执行此代码的线程2：
condition = false;
cv.notify_one();
不幸的是，我遇到了一个时间问题：
T1: condition checks true
T2: condition set to false
T2: cv.notify_one()
T1: cv.wait()
线程1完全
浏览 3提问于2012-07-29得票数 6
回答已采纳
1回答
注意:我发现标题中的“嵌入”这个词是不好的选择，但我会保留它。
我看到很多代码都是这样的：
type A struct {
mu sync.Mutex
...
}
并像这样使用它：
a := &A{}
a.mu.Lock()
defer a.mu.Unlock()
a.Something()
它是比局部互斥还是全局互斥更好？
a := &A{}
var mu sync.Mutex
mu.Lock()
defer mu.Unlock()
a.Something()
我应该什么时候使用前者，还是以后使用？
浏览 0提问于2017-07-06得票数 20
回答已采纳
我正在用P2P协议编写一个对等体。我有一个全局变量，表示我想要与之通信的对等点的映射。但是，我希望每隔180秒更新一次此映射，而不会休眠或阻塞客户端，因为我仍然需要能够发送数据包并处理传入的数据包。
到目前为止，客户端的结构可重采样为如下所示：
var map[int]Peer
func main() {
for {
// Every 180 seconds, update peers map
// send packets / receive packets
}
}
有问题的部分是定时更新。我已经搜索过了，很多可能的解决方案都是使用time.A
浏览 19提问于2021-11-30得票数 1
我目前正在学习操作系统操作系统:三个简单的部分，它引入了pthread_cond_wait()函数，它使调用者睡眠。
它说，在它被调用之后，它就会打开互斥锁，然后让来电者睡觉。
我不知道为什么在它被调用后解锁这个互斥体。为什么会这样呢？请帮助我理解这个原因。谢谢。
浏览 1提问于2019-09-12得票数 0
回答已采纳
我使用boost::interprocess在共享内存中创建了一个boost::multi_index数据结构。有许多客户端进程将访问此数据结构。访问时，我会锁定数据结构。我遇到的问题是，一旦客户端进程正在访问数据结构，并且在没有释放被占用的锁的情况下崩溃，那么所有其他客户端进程都无法访问该数据结构。我用的是boost::interprocess::named_mutex，我知道boost::interprocess::file_lock可以在进程崩溃的时候自动释放，但是因为他有很多的限制，所以我没有用，不知道有没有解决这个问题的好办法，谢谢！
浏览 16提问于2019-07-03得票数 2
1回答
我有程序，可以使用动态链接库插件。如果程序想要询问插件的一些决定，它将发送消息到dll并等待结果。
程序还提供了动态链接库，指向GetSymbol函数的指针。使用此函数，动态链接库可以向程序请求某些符号。
我已经创建了某种dll代理。如果程序向动态链接库发送消息，则动态链接库向客户端发送xmlrpc调用并返回结果。Dll还有第二个线程，作为xmlrpc服务器。因此客户端可以发送xmlrpc调用来请求符号。
我发现了一些有趣的问题。我不知道哪里出了问题。当我在线程1中使用GetSymbol函数时，一切工作正常。但是当我试图在线程2程序锁中使用它时...有可能吗？程序如何知道哪个DLL线程调用了G
浏览 0提问于2012-03-06得票数 1
1回答
由不同的并发运行的posix线程提供和读取动态增长的结构数组是否可取，甚至是可能的？我必须在哪里为这类应用程序寻找最佳实践--有没有什么是“共同的智慧”？我是这个领域的新手，需要一些初始的指示，从哪里开始，寻找什么。这里似乎有很多可能性，我不想落入初学者的陷阱。
浏览 2提问于2009-11-02得票数 2
在等待std::conditional_variable时，我对std::unique_lock的需求感到非常困惑。所以我研究了VS2013中的库代码，并且变得更加困惑。下面是std::conditional_variable::wait()的实现方式：
void wait(unique_lock<mutex>& _Lck)
{ // wait for signal
_Cnd_waitX(&_Cnd, &_Lck.mutex()->_Mtx);
}
这是在开玩笑吗？将互斥锁包装在unique_lock中，然后什么也不做，只是
浏览 0提问于2013-10-24得票数 0
我使用以下代码在几个正在运行的进程之间同步对共享资源的互斥访问。
互斥对象是这样创建的：
Mutex mtx = new Mutex(false, "MyNamedMutexName");
然后我用这个方法进入互斥部分：
public bool enterMutuallyExclusiveSection()
{
//RETURN: 'true' if entered OK,
// can continue with mutually exclusive section
bool bRes;
try
{
浏览 1提问于2013-03-17得票数 19
回答已采纳
当我比较sync.mu、sync.Map和atomic.Value在go中的效率时，预期sync.mu比后两者的效率要低。但当我进行基准测试时，发现使用sync.mu的执行时间较短。所以我想知道原因，或者有最好的做法。
码
源代码在这里，将其简化如下：
sync.Map：Scene1:改变map中的随机kv对，sync.mu与Scene1
// sync.mu reader
mu.Lock()
tmp := tA[idx]
mu.Unlock()
// sync.mu writer
mu.Lock()
tA[idx] = data
mu.Unlock()
// sync.Map reader
浏览 9提问于2022-03-27得票数 0
回答已采纳
5回答
我有一个在线程中使用的全局结构，它是我利用pthread.h创建的。其中有更新变量的并发线程事件。因此，我通过大量的调试发现，结构中的数据经常是不同步的。
在C中没有像"synchonized“这样的关键字。那么我如何阻塞数据结构来保持它的有效性呢？
我的结构是：
struct thread_data
{
int nr;
int time;
};
struct thread_data thread_data_array[MAX_THR];
MAX_THR被定义为10例如..
使用pthread_create将我的数据传递给新线程
pthread_create(&t
浏览 0提问于2010-11-15得票数 1
我对多线程很陌生，并且正在尝试使用互斥。我非常肯定我理解什么是互斥的概念，但是我发现关于实际使用它们的文档是非常缺乏的。我遇到的主要问题之一是试图控制对特定变量的访问。
当我锁定互斥锁(不管我使用哪种锁)时，会发生什么？似乎没有任何方法将特定的变量/资源分配给互斥变量，所以它仅仅锁定范围内的所有变量吗？如果变量A和变量B都声明在我希望单独互斥的作用域中(即线程1可以访问变量A，而线程2访问变量B)，那么怎么办？
浏览 6提问于2014-08-29得票数 0
回答已采纳
1回答
有人能解释一下下面的代码有什么问题吗？
struct CSection {
CSection( pthread_mutex_t* mP ) {
m_lockPtr = mP;
pthread_mutex_lock( m_lockPtr );
}
~CSection() {
pthread_mutex_unlock( m_lockPtr );
}
pthread_mutex_t* m_lockPtr;
};
////////////////MAIN CODE ///////////////
浏览 7提问于2020-09-03得票数 0
2回答
互斥锁是什么数据类型？
我想设置一个int作为互斥量。
我看到锁被设置为int，互斥锁被声明为so pthread_mutex_t mtx，在哪里设置互斥锁的数据类型，或者将互斥锁连接到变量？
浏览 0提问于2011-04-24得票数 1
回答已采纳
1回答
我在服务器上有一个.txt文件，它将用于写入大量数据，然后每次用户登录系统时读取数据。
我的问题是：
在合适的时间内，使用该系统的用户总数约为5000人。我只是担心在同一时间关闭、打开、读取和写入相同的文件以及多个用户。你能建议它是安全的，它会工作吗？
浏览 1提问于2014-11-03得票数 0
假设有一个生产者和多个使用者，他们使用std::queue，为了保护std::queue中的数据，在访问这个std::queue时必须使用互斥锁。
但是用两个单独的锁怎么样？一个给pop，一个给push？我觉得用两个单独的锁可能会更快。
我看了一下STL源代码。默认情况下，std::queue由std::deque实现。pop_front()和push_back()使用两个单独的迭代器来访问数据，一个用于第一个元素，一个用于最后一个元素。
void push_front(const value_type& __x){
if (this->_M_impl._M_start.
浏览 2提问于2015-07-26得票数 0
回答已采纳
假设我在共享内存中有一个进程间向量。一个进程可能正在迭代它。如果另一个进程希望并发清除向量，那么我需要做什么才能避免在执行迭代的过程中崩溃呢？
进程#1 -在共享内存中遍历向量
using namespace boost::interprocess;
typedef allocator<int, managed_shared_memory::segment_manager> ShmemAllocator;
typedef vector<int, ShmemAllocator> MyVector;
managed_shared_memory segment(crea
浏览 1提问于2014-08-28得票数 1
回答已采纳
我正在用Rust编写一个PKCS#11库，我遇到了一些问题，比如如何使调用者提供的锁定机制(如CreateMutex、DestroyMutex、LockMutex、UnlockMutex )与Rust的互斥锁实现相协调。 当然，C中的Mutexes并不依赖于数据。它们只是在一个段上设置一个锁，程序员负责创建/销毁和锁定/解锁互斥锁。然而，Rust确实将数据绑定到互斥锁本身。 我如何协调这两种情况:当调用程序提供锁定机制(不绑定到数据和手动创建/锁定/解锁/销毁)时，没有提供锁定机制并使用Rust锁定(绑定到数据和MutexGuard以及互斥锁的作用域删除/解锁)？ 我是否应该使用parkin
浏览 53提问于2021-09-27得票数 4
2回答
据我所知他们不是。
原子对象不存在数据竞争，但它们仍然会受到竞争条件的影响:两个线程可能以不可预测的顺序启动，使程序的结果变得不确定。
共享数据将是“安全的”(受atomics保护)，但顺序或时间仍然可能是错误的。
你能确认一下吗？
浏览 3提问于2019-03-02得票数 3
回答已采纳
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
回答已采纳
2回答
我必须做一个程序，它有一个共享变量(计数器与初始值= 35)和5个线程。我必须编写程序，让每个线程访问计数器的值并将其减1。这应该会继续下去，直到计数器= 0。
这就是我到目前为止的代码，但问题是只有一个线程将counter的值递减到0。
#include <stdio.h>
#include <time.h>
#include <stdlib.h>
#include <pthread.h>
#define NTHREADS 5
void *thread_function1(void *);
void *thread_function2(voi
浏览 1提问于2011-10-16得票数 0
回答已采纳
当我尝试将一个变量从一个任务发送到另一个任务时，我无法使用xQueueReceive接收任何内容。我使用UART和Arduino Mega。我会向Arduino发送一个char，然后Arduino会将这个char发送到另一个设备。但是我得不到任何结果。下面是我的代码： #include <Arduino_FreeRTOS.h>
#include <semphr.h>
#include <queue.h>
SemaphoreHandle_t xSerialSemaphore;
QueueHandle_t queue;
void TaskWrite( vo
浏览 62提问于2020-12-08得票数 0
4回答
像这样的东西是有效的：
std::vector<std::vector<int>> data;
std::shared_mutex m;
...
void Resize() {
// AreAllVectorsEmpty: std::all_of(data.begin(), data.end(), [](auto& v) { return v.empty(); }
if (!AreAllVectorsEmpty()) {
m.lock();
if (!AreAllVectorsEmpty()) {
浏览 3提问于2018-05-29得票数 1
我已经开始在事件驱动的体系结构中实现微服务。因此，我的一些服务是发布事件和侦听其他事件。例如，当一个操作依赖于单个事件时，实现侦听器是非常简单的；
ORDER SERVICE
1. Publishes `ORDER_INTENT_EVENT` then
2. Listens for `CREDIT_AVAILABLE_EVENT` then
3. Finishes the `Order`
CREDIT SERVICE
1. Listens for `ORDER_INTENT_EVENT` then
2. Verifies if the client has credit
浏览 1提问于2018-07-19得票数 2
1回答
我想让我的程序更有效率：
我是否可以将一个*sync.Mutex变量给一个结构，以便当我执行一个obj.Mutex.Lock()时，它只锁定对该特定对象的goroutines操作？
示例：
package main
import (
"fmt"
"sync"
"time"
)
type mystruct struct {
Counter int
Mutex *sync.Mutex
}
func (obj *mystruct) incrementCount() {
for i := 0; i
浏览 1提问于2020-04-18得票数 0
回答已采纳
2回答
安全销毁线程池
、、、、
考虑以下用C++14编写的简单线程池的实现。
注意到每个线程都处于休眠状态，直到被通知唤醒--或者是一些虚假的唤醒调用--以下谓词的计算结果为true
std::unique_lock<mutex> lock(this->instance_mutex_);
this->cond_handle_task_.wait(lock, [this] {
return (this->destroy_ || !this->tasks_.empty());
});
此外，观察到ThreadPool对象使用数据成员destroy_来确定其是否被销毁-
浏览 1提问于2015-03-21得票数 4
回答已采纳
2回答
可能重复：
我正在开发一个iOS应用程序，在这个应用程序中我使用sqlite数据库。我必须执行多线程处理，但是在sqlite数据库上，我只能在time.So上做一件事，我需要实现信号量.So的概念，请帮助我
浏览 5提问于2012-08-20得票数 3
回答已采纳
3回答
我过去常常看到“无锁数据结构”这个术语，并认为“那一定很复杂”。然而，我一直在读"C++ Concurrency in Action“，它似乎编写了一个无锁的数据结构，您所要做的就是停止使用互斥/锁，并将其替换为原子代码(以及可能的内存排序障碍)。
所以我的问题是-我是不是漏掉了什么？有了C++11，事情真的变得那么简单了吗？编写无锁的数据结构仅仅是用原子操作替换锁的一种情况吗？
浏览 0提问于2014-01-12得票数 6
我正在为一个使用2.6.24.3内核的嵌入式Linux项目开发一个用户空间应用程序。我的应用程序通过创建2个pthread在两个文件节点之间传递数据，每个pthread都处于休眠状态，直到异步IO操作完成，此时它将唤醒并运行完成处理程序。
完成处理程序需要跟踪有多少传输挂起，并维护一些链表，一个线程将添加到这些链表中，而另一个线程将删除这些链表。
// sleep here until events arrive or time out expires
for(;;) {
no_of_events = io_getevents(ctx, 1, num_events, events, &
浏览 7提问于2010-05-19得票数 6
回答已采纳
我的项目由两个线程组成:一个主线程，另一个处理另一个窗口内容的线程。因此，当主线程想要求另一个窗口更新自己时，它调用如下所示的绘制函数：
void SubApplicationManager::draw() {
// Zero number of applications which has finished the draw counter
{
boost::lock_guard<boost::mutex> lock(SubApplication::draw_mutex);
SubApplication::num_draws = 0;
}
//
浏览 6提问于2015-06-15得票数 0
回答已采纳
2回答
我正在做一个班级项目。我需要设计一个cpu，一个长期调度器(Lts)和一个调度器。.Cpu和lts是线程，它们操作相同的线程安全链表(这意味着链表上的所有操作必须是互斥的)Boot有三个组件。(Boot:它只在执行开始时工作一次，并从就绪队列中获取第一项。Fetch:它将从正在运行的进程的代码段中获取IPth指令到IR。并执行它将执行IR中的指令)。当一个虚拟进程的创建时间为进程创建前执行的指令总数时，Lts会将该进程放入就绪队列中。is.Creation time是指在进程创建前执行的指令总数。
DWORD WINAPI cpuFunction(){
boot();
whi
浏览 4提问于2012-12-23得票数 0
回答已采纳
我正在编写一个程序，它简单地演示了从一个有界缓冲区的写入和读取，因为它输出所期望的值以及实际读取的值。当我将N定义为低值时，程序将按预期执行。但是，当我增加值时，我开始看到意想不到的结果。据我所知，我正在使用两个线程创建数据竞赛。
通过查看输出，我认为我已经将其缩小为大约三个数据竞赛示例，如下所示：
一个线程写入缓冲区，另一个线程读取。两个线程同时写入缓冲区。两个线程同时从缓冲区中读取。
下面是我的密码。对于#include语句来说，格式非常奇怪，所以我忽略了它们。
#define BUFFSIZE 10000
#define N 10000
int Buffer[BUFFSIZE];
浏览 4提问于2012-04-13得票数 1
回答已采纳
我正在编写一个Java程序，它与我的Linux服务器上的一个C程序(一个客户机/服务器聊天程序)接口。现在，我正在实现一个阻塞功能，用于阻塞输入，直到用户在将输入发送到服务器之前按下"Enter“。为此，我有两个选择:繁忙循环和互斥。互斥显然是最好的选择，但我遇到了一个问题，有时输入根本不会发送到服务器。不过，在繁忙循环中，我只需取消设置一个标志，它就能正常工作。 忙循环： while(!this.inputField.isReady()){}
// send data in inputField to server
this.inputField.setReady(false);
浏览 11提问于2021-04-30得票数 0
1回答
并发排除调优
、、
void method1() {
if (is_true) {
mutex1.lock();
condition_var.wait(mutex1,
[=] { return is_true == false; });
mutex1.unlock();
}
// do some work
}
void method2() {
if (is_true) {
mutex1.lock();
condition_var.wait(
浏览 1提问于2015-09-27得票数 0
回答已采纳
1回答
当我有一个std::condition_variable cond和一些bool flag时，我可以使用谓词等待它：
cond.wait_for(some_lock, std::chrono::milliseconds(100), { return flag; })
现在我想知道:从技术上讲，C++在C++11中只有一个合适的多线程内存模型，而在多线程上下文中访问flag变量基本上是没有定义的。因此，我必须声明它为std::atomic<bool>，以避免这种未定义的行为，对吗？
我特别想知道:如果我没有声明它为std::atomic，那么我是否会一直从flag中读取陈旧的值，因为
浏览 2提问于2018-06-12得票数 0
回答已采纳
2回答
我对线程很陌生。如果我错了，那么互斥锁就会锁定对共享数据结构的访问，以便其他线程在解锁之前不能使用它。因此，让我们考虑有两个或更多的共享数据结构。那么，我应该为不同的数据结构创建不同的互斥对象吗？如果不是，那么std::mutex如何知道它应该锁定哪个对象？如果我必须同时锁定多个对象呢？
浏览 5提问于2015-05-27得票数 2
回答已采纳
4回答
我是多线程的新手，我正在尝试让一些std:列表成为线程安全的。在列表中添加或删除项目时，执行mutex.lock()和mutex.unlock()是否足够？同样，我只是想让它们成为线程安全的。
谢谢
浏览 0提问于2016-08-03得票数 7
2回答
我的应用程序中有一个命名的互斥体。
private Mutex TaskExitStatus = new Mutex(false, "TaskExit")
我在使用TaskExitStatus.WaitOne()的方法中获取互斥对象
如果退出应用程序时不释放互斥体，会发生什么情况？这个互斥物会被安全地处理吗？
更新1:当应用程序退出时没有发布时，命名互斥和未命名互斥的行为都一样吗？
更新2这是我从上读到的
使用CloseHandle函数关闭句柄。当进程终止时，系统会自动关闭句柄。当最后一个句柄关闭时，互斥对象将被销毁。
浏览 5提问于2012-10-23得票数 5
回答已采纳
我试着读SimpleQuery的代码，socket.go中的函数使我感到困惑。在这个函数中，有两个局部互斥：
func (socket *mongoSocket) SimpleQuery(op *queryOp) (data []byte, err error) {
var wait, change sync.Mutex
var replyDone bool
var replyData []byte
var replyErr error
wait.Lock()
op.replyFunc = func(err error, reply *reply
浏览 7提问于2017-08-14得票数 1
回答已采纳
我有一个固定大小的数组(例如：struct bucket[DATASIZE])，一开始我就从文件中加载信息。由于我关心的是可伸缩性和执行时间，所以没有使用动态数组。
每次我处理一半的数组时，我都可以自由地用文件中的更多数据替换这些点。我不清楚该怎么做，但我想到了pthread来启动两个并行任务:一个是实际的数据处理，另一个是确保填充数组。
但是，我在pthread上看到的所有示例都表明，它们都在处理相同的任务，但都是并发的。有没有办法让他们做不同的事情？有什么想法或想法吗？
浏览 1提问于2011-03-31得票数 0
回答已采纳
例如，如果互斥对多线程访问没有弹性，多线程就永远不会工作(例如，同时调用mutex.lock()不会把事情搞砸)。
这是否也适用于条件变量？具体地说，我想释放一个锁，然后调用cond.notify_one()。理论上，另一个线程可以在通知之前抢占锁，并开始自己调用cond.notify_one()。是否可以保证这将是良好的行为？
那么在堆上分配的简单数据结构呢？假设数据结构在读取时不会进行自我调整，如果数据结构只被读取，那么允许并发访问还可以吗？是否有关于哪些stl数据结构和成员函数允许并发读取而不需要锁定的文档？
浏览 0提问于2010-10-19得票数 3
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
腾讯会议
实时音视频活动推荐
腾讯云开发者
