锁定互斥锁与访问磁盘
锁定互斥锁与访问磁盘是两个不同的概念，但它们都与计算机系统的性能和稳定性有关。
- 锁定互斥锁
锁定互斥锁是一种用于多线程编程中的同步机制，它可以确保在任何时刻只有一个线程访问共享资源。当一个线程获得互斥锁时，其他线程将被阻塞，直到锁被释放。这种机制可以避免多个线程同时访问共享资源，从而避免数据不一致和竞争条件的发生。
优势：
- 保证数据一致性：锁定互斥锁可以确保在任何时刻只有一个线程访问共享资源，从而避免数据不一致和竞争条件的发生。
- 提高性能：锁定互斥锁可以避免多个线程同时访问共享资源，从而减少了不必要的资源竞争，提高了系统的性能。
应用场景：
- 多线程编程：锁定互斥锁是多线程编程中常用的同步机制，可以确保在任何时刻只有一个线程访问共享资源。
- 数据库操作：在数据库操作中，锁定互斥锁可以确保在任何时刻只有一个线程访问数据库，从而避免数据不一致和竞争条件的发生。
推荐的腾讯云相关产品：腾讯云提供了多种云计算服务，包括云服务器、云数据库、负载均衡、CDN等，可以帮助用户构建高可用、高性能的云计算应用。
产品介绍链接地址：腾讯云
- 访问磁盘
访问磁盘是计算机系统中读取或写入磁盘上文件的操作。磁盘是计算机系统中最慢的存储设备之一，因此访问磁盘的性能对于计算机系统的整体性能有着重要的影响。
优势：
- 存储大量数据：磁盘可以存储大量的数据，比内存和CPU更加可靠和持久。
- 降低成本：磁盘的成本相对较低，可以为用户提供更多的存储空间。
应用场景：
- 数据存储：磁盘可以用于存储大量的数据，包括操作系统、应用程序、用户数据等。
- 数据备份：磁盘可以用于备份重要的数据，以防止数据丢失或损坏。
推荐的腾讯云相关产品：腾讯云提供了云硬盘、对象存储、备份与恢复等云存储服务，可以帮助用户构建高可用、高性能的云存储应用。
产品介绍链接地址：腾讯云
相关·内容
2回答
解锁未被锁定的std::mutex是UB。为何会这样呢？为什么它没有效果，因为互斥锁还没有锁定，或者已经被解锁了，那么再次调用解锁有什么害处呢？
浏览 2提问于2021-08-31得票数 10
回答已采纳
如果互斥锁可以被线程递归锁定，我就不理解互斥锁的用法。为什么有人要递归地锁定互斥锁呢？在什么情况下，他们会使用这个？
浏览 1提问于2010-08-22得票数 1
我对线程有些陌生，我正试图了解它在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
1回答
由不同的并发运行的posix线程提供和读取动态增长的结构数组是否可取，甚至是可能的？我必须在哪里为这类应用程序寻找最佳实践--有没有什么是“共同的智慧”？我是这个领域的新手，需要一些初始的指示，从哪里开始，寻找什么。这里似乎有很多可能性，我不想落入初学者的陷阱。
浏览 2提问于2009-11-02得票数 2
2回答
我猜这里已经问过这个问题了，但我找不到这个特别的问题。它只是锁定锁和解锁之间的代码部分，还是锁定全局变量？就像下面的代码
pthread_mutex_lock(&mtx);
bitmap[index] = 1;
pthread_mutex_unlock(&mtx);
互斥锁只是锁定了这行代码？有没有一种方法可以锁定特定的变量，而不只是锁定使用它们的代码部分？
浏览 2提问于2012-02-22得票数 1
回答已采纳
1回答
在代码中，展示了互斥的使用示例。特别是，互斥对象首先在main之前声明。
pthread_mutex_t mutexsum;
由互斥体“保护”的特定变量是全局结构dotstr.sum中的dotstr：每个线程在获得lock后都会在上面写入。对应的代码是：
pthread_mutex_lock (&mutexsum);
dotstr.sum += mysum;
printf("Thread %ld did %d to %d: mysum=%f global sum=%f\n",offset,start,end,mysum,dotstr.sum);
pthread_mut
浏览 0提问于2015-08-19得票数 2
回答已采纳
1回答
我是GO的新手，我不得不在我的代码中使用Mutex Lock/Unlock来防止并发访问。但是在我将Lock/Unlock添加到我的代码后，我的测试开始永远运行。我已经简化了我的用例，并添加了类及其测试文件。如果我单独运行测试，所有测试都运行得很好。但是如果我对整个文件运行，前两个文件已经完成，但第三个文件永远运行。如果我删除了Lock/Unlock，那么运行就会正确执行。 如果有人能指出我在这里做错了什么，那就太好了。 测试代码： package anything
import (
"sync"
)
var maxLimit = 5
var Store = Ca
浏览 26提问于2021-03-24得票数 0
回答已采纳
1回答
所有锁都是使用原子操作实现的吗？在一些书中，它说“一个锁需要几个原子操作”。我认为原子操作和锁是不同的东西。但看来我错了。锁和原子操作之间有什么关系？
浏览 1提问于2019-03-16得票数 3
结构或链表中的互斥变量是如何实际生效的。它会锁定整个结构吗？实际上，当它在一个结构中声明时，它是如何工作的呢？它工作的内部细节是什么？ 下面是一个来自oracle站点的示例代码： typedef struct node1 {
int value;
struct node1 *link;
pthread_mutex_t lock;
} node1_t;
node1_t ListHead;
node1_t *delete(int value)
{
node1_t *prev, *current;
prev = &am
浏览 31提问于2020-07-01得票数 1
1回答
我是新手，所以请温柔点。
所以我在我的代码中使用互斥已经有几个星期了。我理解它背后的概念:锁定对某个资源的访问，与其交互(读或写)，然后再为其他人解锁它。
我使用的互斥码主要是复制粘贴调整。代码运行，但我仍然试图把我的头围绕着它的内部工作。到目前为止，我一直在结构中使用互斥锁结构。今天我发现了，这让我完全不知道互斥锁到底锁了什么。下面是示例代码的一部分：
var state = make(map[int]int)
var mutex = &sync.Mutex{}
var readOps uint64
var writeOps uint64
// Here we start 10
浏览 0提问于2019-06-22得票数 7
回答已采纳
我有一个函数，如下所示:线程使用std::lock_guard互斥锁获取锁，并通过ofstream写入文件。
当当前文件大小增加最大大小时，我想要创建一个独立的线程，它应该压缩文件并终止。
我想了解在pthread_create还在作用域时调用std::lock_guard的含义。
安全吗？锁也会应用到新线程(我不打算这样)吗？
void log (std::string message)
{
std::lock_guard<std::mutex> lck(mtx);
_outputFile << message << std::endl;
浏览 0提问于2019-02-15得票数 1
回答已采纳
4回答
解释互斥是如何工作的
、、、
现在，我正在尝试学习多线程和mutext。但我不明白。例如，我将条目添加到另一个线程中，然后添加到主程序中：
GMutext* lock;
g_mutex_lock (lock);
g_list_prepend(list, "Some data");
g_mutex_unlock (lock);
在这种情况下，列表会发生什么情况？添加的元素列表，以及在g_mutex_unlock之前无法从主线程访问。还是我理解错了？
谢谢。
谢谢。
浏览 0提问于2010-07-15得票数 1
回答已采纳
1回答
时间间隔(线程)
、、
我必须模拟轮盘赌游戏，因为我们的老师给了我们一个练习(没有评分)。它必须是一个多线程客户端-服务器应用程序。我正在设计服务器(客户端非常简单，它只需要发送赌注的请求)，但是我被卡住了。我有两个线程函数，croupier:这个函数每隔N秒拉出一次数字(在命令行中指定)玩家:这个函数读取croupier拉出的数字并将赌注插入到共享列表中。每个玩家可以下注一次或多次。
我的问题是:我可以使用cond_timedwait来模拟两个数字被拉出之间的时间间隔吗？有没有其他方法可以做到这一点？
void *croupier(void *arg) {
struct timespec cond_time;
t
浏览 4提问于2010-11-10得票数 0
7回答
我所读到的所有关于线程互斥锁的文档只声明互斥锁阻止多个线程访问共享内存，但是如何在程序中指定这到底是什么呢？是程序中的所有全局变量，锁定和解锁函数之间访问的变量，还是.？我在p线程上找到的所有东西，包括示例，都是令人恼火的模糊。
浏览 4提问于2013-10-03得票数 7
回答已采纳
2回答
锁排序或调度的问题
、、、、
我有一个使用pthread的C应用程序。
在两个线程(比如A和B)之间存在锁争用，A首先获得锁，而B正在等待锁，一旦A完成并释放锁，B仍然没有获得它，一段时间后A再次获得锁(A确实在循环中获取并释放)。
如果我将我的进程附加到gdb，并在线程A放弃锁之后暂停线程A，然后在线程B上手动继续，那么它就会获得锁并执行所需的操作。
在我看来，这不像是一把死锁。是什么阻止了线程B获得锁？任何帮助都是非常感谢的。
示例代码：
线程A：
while (true)
{
lock.acquire(lock)
// Do stuff
lock.release(lock)
浏览 1提问于2013-02-07得票数 0
回答已采纳
我用C语言制作了一个带有互斥变量和条件变量的教育应用程序。
下面是一个简短的例子：
while (!(is_done == 0))
pthread_cond_wait(&cond, &mutex);
pthread_mutex_unlock(&mutex);
你能解释一下吗，当信号使互斥锁被锁定时，当信号使互斥锁被锁定时，为什么在“同时”状态之后(以及从第二个线程接收信号)我们需要解锁互斥锁？
我从网络上获得了很多例子，但是当我想在接收到信号后使用互斥锁时，我需要解锁互斥锁吗？Ofc我想在接收信号后处理这个线程
浏览 1提问于2018-06-20得票数 0
回答已采纳
1回答
我有一个全局矩阵(类型为vector< vector< char> >)，我需要几个线程才能以我所说的方式写入其中。起初，我考虑只使用一个互斥锁，因为我害怕竞争条件(access+write可能不是原子的)，然后我使用了互斥锁矩阵。我对此不是很确定。这似乎也是同样的问题。
你能帮帮我吗？如果你需要，我会添加更多的细节。谢谢
浏览 2提问于2011-06-14得票数 0
回答已采纳
我用pthread编写了一个多线程程序，使用生产者-消费者模型。
当我使用英特尔VTune profiler分析我的程序时，我发现生产者和消费者在pthread_mutex_unlock上花费了大量时间。我不明白为什么会发生这种事。我认为线程可能会等待很长时间才能获得互斥锁，但释放互斥锁应该很快，对吧？
下面的快照来自英特尔VTune。它显示了消费者尝试从缓冲区获取项目的代码，以及每个代码行所消耗的时间。
我的问题是，为什么pthread_mutex_unlock有这么大的开销？问题出在pthread互斥锁本身还是我使用它的方式上？
浏览 4提问于2013-06-03得票数 15
回答已采纳
我使用boost::interprocess在共享内存中创建了一个boost::multi_index数据结构。有许多客户端进程将访问此数据结构。访问时，我会锁定数据结构。我遇到的问题是，一旦客户端进程正在访问数据结构，并且在没有释放被占用的锁的情况下崩溃，那么所有其他客户端进程都无法访问该数据结构。我用的是boost::interprocess::named_mutex，我知道boost::interprocess::file_lock可以在进程崩溃的时候自动释放，但是因为他有很多的限制，所以我没有用，不知道有没有解决这个问题的好办法，谢谢！
浏览 16提问于2019-07-03得票数 2
2回答
我正在为多线程的概念而苦苦挣扎。
有两个线程访问共享结构。我的想法是让ThreadTwo首先获取锁并将data设置为true，然后如果data设置为true，则ThreadOne run...which进入睡眠状态，并在data设置为false后发出信号唤醒。
我看到的情况是：ThreadOne进入睡眠状态，在ThreadTwo禁用data之后，两个线程似乎都处于死锁状态，或者更确切地说，它们被卡住了。
我的理解是:我在AccessShm(shmInfo, GET)的末尾解锁互斥锁，我相信pthread_cond_signal需要已经获取锁，因为它在休眠之前解锁，一旦从ThreadTwo发出信
浏览 6提问于2021-10-01得票数 0
1回答
在每一篇关于互斥的教程中，互斥被描述为一种防止多个线程同时访问相同资源的方法。但这些资源是什么。我知道资源可以是很多东西，比如变量，但是如何定义那些不应该同时由另一个线程使用的变量呢？互斥锁如何知道要“锁定”哪些变量？我不明白编译器在执行代码之前如何知道Mutex在函数mutex.lock和mutex.release之间应该锁定什么。
浏览 2提问于2022-09-29得票数 3
3回答
C++11多线程锁和原子原语
、、、、
(导致两个问题的问题)
在C++11中，锁是原子的，其中一个绝对可以确保两个线程不能同时获得锁？
如果以上答案是“是”，那么双重检查锁定的目的是什么？
最后，为什么我们需要std:: lock ()，因为我们可以只使用原子原语(很明显，我们知道它是原子)，并根据是否获得锁而将其设置为1或0？
浏览 9提问于2013-09-15得票数 1
回答已采纳
我对多线程很陌生，并且正在尝试使用互斥。我非常肯定我理解什么是互斥的概念，但是我发现关于实际使用它们的文档是非常缺乏的。我遇到的主要问题之一是试图控制对特定变量的访问。
当我锁定互斥锁(不管我使用哪种锁)时，会发生什么？似乎没有任何方法将特定的变量/资源分配给互斥变量，所以它仅仅锁定范围内的所有变量吗？如果变量A和变量B都声明在我希望单独互斥的作用域中(即线程1可以访问变量A，而线程2访问变量B)，那么怎么办？
浏览 6提问于2014-08-29得票数 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
1回答
嗨，我是C的新手，我试着理解互斥，条件和线程。我有线程工作原理的基本知识。如果我错了，请纠正我，据我所知，其中一个线程正在等待另外两个线程发送一个信号来唤醒他。由于互斥锁，代码一次只能由一个线程运行，线程2获取锁并运行代码，sleep(1)帮助替换线程2不再运行它，线程3获得锁并运行代码等等。只有锁定并释放互斥锁的线程。一旦到达COUNT_LIMIT 12，它就会向等待线程发送一个信号，即线程1。
所以我的问题是，这几段代码在void *watch_count中
pthread_mutex_lock(&count_mutex)；
pthread_cond_wait(&coun
浏览 3提问于2019-12-12得票数 0
2回答
如何为一组线程共享互斥锁？
、、、、
我试着用线程做一些事情，并同步它们：
我怎么能只对一组线程使用互斥对象呢？
假设我有t0，t1，t2，.t20。线程同时运行，我希望对偶数线程有一个锁，对于奇数线程有其他锁.前十锁一锁，其余十锁一锁，每锁一锁。我的意思是，根据它的数据对线程进行分组(这个函数中的第四个参数)：
int pthread_create(pthread_t *线程，pthread_attr_t *attr，void *(*start_routine)(void *)，pthread_t *arg)；
并为一组线程共享互斥对象。
我正在做一项银行项目，我想把所有的电话都锁上，试图访问同一个帐号。(作为关键部分的CR
浏览 6提问于2011-11-14得票数 1
请参阅下列经典生产者-消费者代码：
int main()
{
std::queue<int> produced_nums;
std::mutex m;
std::condition_variable cond_var;
bool done = false;
bool notified = false;
std::thread producer([&]() {
for (int i = 0; i < 5; ++i) {
std::this_thread::sleep_for(std
浏览 0提问于2018-05-21得票数 6
回答已采纳
2回答
有人能提供一些例子/提示/指示如何解决以下分配:资源可以使用2种类型的进程:黑和白。当资源被白进程使用时，黑进程不能使用它，反之亦然。实现对资源的访问，避免饥饿。在以前的一篇文章中，我被建议使用seqlock算法的一个变体，但是我不知道如何调整这个分配算法。
编辑:这是我到目前为止编写的代码
#include <stdio.h>
#include <pthread.h>
#include <sys/wait.h>
#include <unistd.h>
#include <stdlib.h>
struct RW;
struct RW
浏览 2提问于2013-12-01得票数 0
回答已采纳
2回答
是一个能够执行此操作的互斥锁
、、、、
我有这样一种情况，我有多个线程访问剪贴板，并在一些休眠状态下执行一个操作。基本上，我不想把错误的东西复制到剪贴板上，并以不正确的方式执行一些东西。
目前，我有一个想法是使用互斥锁来锁定std::string变量，并在其中存储所需的数据，然后将其存储到剪贴板中。在我完成操作后，我解锁它。然后另一个线程访问变量，然后是剪贴板和操作。
因为我从来没有使用过互斥锁，所以我的问题是--仅仅做上面的事情它就能工作吗？
我使用下面的库来管理剪贴板：
浏览 0提问于2021-03-31得票数 0
4回答
当mutex或.lock()或.try_lock()锁定内存的哪一部分，只是函数还是整个程序被锁定？
浏览 4提问于2020-02-05得票数 1
回答已采纳
在等待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
2回答
我之前被问到一个关于互斥的问题，代码运行良好，但我对这个结果感到困惑：
::std::mutex s_mutex;
void funcA()
{
s_mutex.lock();
printf( "funcA \n" );
s_mutex.unlock();
}
void funcB()
{
s_mutex.lock();
funcA();
printf( "funcB \n" );
s_mutex.unlock();
}
int main()
{
funcB();
retur
浏览 0提问于2019-10-24得票数 0
1回答
在Windows 7 (64位)下使用来自MSYS2的POCO1.9.0-1。
我有一个线程，发送一个Poco:条件三次，睡眠300毫秒。
我有两个线程使用两个不同的类EvListenerA和EvListenerB，它们从Poco::Runnable扩展而来，它们正在等待相同的Poco：：条件来使用std::cout显示消息。
对于第一和第二信号，没有问题，但是当启动第三信号时，只有线程EvListenerA才能正确捕获它。
这是代码：
/*
* main.cpp
*
* Created on: 6 jun. 2019
* Author: ccortiz
*/
#inc
浏览 2提问于2019-06-06得票数 0
回答已采纳
1回答
我正在从头开始创建一个线程池，作为分配的一部分，并且能够创建线程池，然后向每个创建的线程传递一个不断循环的函数。我的问题是如何接受输入并将其传递给已经在执行的pthread。弄清楚这一点后，我将添加互斥锁来将函数锁定到特定的线程，但我无法到达该部分。
class ThreadPool{
public:
ThreadPool(size_t threadCount);
int dispatch_thread(void *(dispatch_function(void *)), void *arg);
bool thread_avail();
int numThrea
浏览 1提问于2011-10-20得票数 0
回答已采纳
1回答
我正在做C++多线程编程。我使用互斥来读写一个队列，以避免死锁。目前，我只启动了1个线程
pthread_mutex_lock(&the_mutex);
但是，在GDB中，我的代码在这里被冻结了，它是挂起的。
为什么？只有一个线程！
谢谢
浏览 2提问于2011-11-06得票数 4
回答已采纳
我有一个运行三个线程的应用程序。这三个线程都在根据全局变量的状态执行一些操作。2个线程运行同一段代码，1个线程运行另一段代码。
例如：
全局变量的初始值为false
gGlobalVarLock = false;
thread 1:
while(true == gGlobalVarLock)
{
/*wait for flag to become false*/
}
/*after the flag becomes false*/
{
mutex.lock();
gGlobalVarLock = true;
/*run some code*/
gGlobalV
浏览 0提问于2016-08-26得票数 0
如果你不知道futex和linuxthreads 0.9是什么，请不要回复。
我可以在一个程序中混合基于futex的互斥量和linuxthreads 0.8或-0.9 (在所有glibc <=2.2和所有uClibc中使用的互斥量)的互斥量吗？
我需要进程间互斥(pshared one，PTHREAD_PROCESS_SHARED)。
那么，如果线程是由linuxthreads启动和管理的，它会被基于pthread_manager的睡眠和唤醒所混淆吗？
我可以将基于futex的互斥锁同时用于进程间和线程间同步吗？
浏览 3提问于2010-02-11得票数 2
回答已采纳
2回答
递归互斥锁背后的思想
、、、、
我在一个学校实验室工作，我们被指示为一个计数程序创建一个递归互斥锁。我写了一些代码(不起作用)，但我认为这主要是因为我不理解使用递归互斥锁背后的真正想法。谁能详细解释一下递归互斥锁应该做什么/看起来像什么？
一般说明:我不是要求一个答案，只是要求一些关于递归互斥锁应该做什么的澄清。
另外，如果有人对此感到好奇，这里有实现此功能所需的代码。我正在编辑/实现的代码是recmutex.c。
recmutex.h
#include <pthread.h>
/*
* The recursive_mutex structure.
*/
struct recursive_mutex {
浏览 5提问于2014-03-26得票数 4
3回答
如果互斥是在一个函数中定义的，那么它的锁是否适用于从该函数调用的函数？即
void f () {
Mutex mutex;
g();
}
锁是否仍然适用于g()中的任何数据修改？
另外，在类方法中定义的锁将只应用于该类的特定实例，这样说对吗？含义：
Class Foo;
Foo foo1, foo2;
(In thread 1) foo1.bar();
(In thread 2) foo2.bar();
每个调用是否能够并发发生？
如果有人能解释/指出解释互斥锁背后机制的链接，那将是一个很好的奖励。谢谢!我目前正在使用Qt Thread库，如果该信息有帮
浏览 0提问于2009-08-02得票数 8
回答已采纳
是否存在明确定义的POSIX互斥对象所有权行为？
线程退出线程崩溃线程崩溃原因是异常
假设线程-1拥有一个互斥体。线程-2正在等待获取相同的互斥对象。线程-1是1/2/3的场景。对线程2有什么影响？
PS :我认为自旋锁的行为是，而不是解锁线程-2，理由是由自旋锁保护的部分无论如何都处于不良状态。
浏览 1提问于2011-09-08得票数 6
我有一个小程序作为测试，如下所示：
#include<pthread.h>
#include<unistd.h>
#include<cassert>
#include<iostream>
using namespace std;
pthread_mutex_t mt;
pthread_t tid[2];
char* msg[]={"thread1","thread2"};
void* tf(void*arg){
pthread_mutex_lock(&mt);
cout<<(ch
浏览 7提问于2017-06-27得票数 1
回答已采纳
3回答
目前，我正试图解决使用C++ STL容器的线程安全问题。最近，我尝试通过使用std::mutex作为成员变量来实现线程安全的std：：向量，只是为了认识到，虽然我可以通过锁定锁使成员函数线程安全，但我无法使lib函数像std：：排序线程安全，因为它们只获得begin()/end()迭代器，这是一般STL中容器和算法之间的基本分离的结果。
于是我想，如果我不能使用锁，那么软件事务内存(STM)呢？
所以现在我被困在这：
#include <atomic>
#include <cstdlib>
#include <iostream>
#include <t
浏览 13提问于2013-12-18得票数 1
我在共享内存上创建了一个共享互斥和条件变量，用于两个进程(生产者和消费者)之间的通信，如果我关闭这两个应用程序，并再次运行，我可以锁定，解锁互斥锁和信号条件变量，而不需要在共享内存上重新创建它们，互斥和条件变量在不重新创建它们的情况下工作良好，这是怎么可能的？使共享互斥和cond变量，使它们的生命周期，直到重启机器？注意:如果我按下ctrl +c并中断使用者并重新启动，两个应用程序都被锁定，并且我需要删除/dev/shm/ipcfile。
浏览 19提问于2020-06-21得票数 0
回答已采纳
这是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回答
互斥作为类成员使用p线程
、、、、
我有三门课，我们叫它们A，B和HardwareDriver。每个类都有一个实例。A和b在两个不同的线程中运行。它们都通过HardwareDriver实例访问硬件。类似于：
Class A {
... };
Class B {
... };
Class HardwareDriver {
public:
int accessHardware();
};
A a;
B b;
HardwareDriver hd;
pthread_t aThread;
pthread_t bThread;
main() {
pthread_create(&aThread,
浏览 1提问于2017-05-26得票数 1
回答已采纳
我有以下简化的程序，它启动一堆子进程，然后使用boost::interprocess::message_queue向每个子进程发送消息。当进程数很少(在我的机器上大约是4个)时，这是可行的，但随着进程数的增加，我会收到以下消息：
head (81473): "./a.out"
Assertion failed: (res == 0), function do_wait, file /usr/local/include/boost/interprocess/sync/posix/condition.hpp, line 175.
我猜是我的同步出了问题..是我做错了什么，还是boo
浏览 15提问于2017-04-28得票数 0
我怀疑互斥锁是否足以确保以下代码示例的线程安全，或者是否需要原子。简而言之，问题是:让idxActive成为常规的int会使这个代码线程不安全吗？或者即使是使用原子线程的代码也不安全？:(如果这很重要，我使用的是32位x86，linux，gcc 4.6。当然，我假设32位或64位没有区别，但如果32位和64位之间有任何区别，我想知道。
#include <memory>
#include <boost/thread/thread.hpp>
#include <string>
#include <vector>
#include <atomi
浏览 0提问于2011-06-30得票数 2
回答已采纳
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
1回答
我有一个基本的样本需要审查(C++)。
假设我有一个函数PublicFunc()，另一个函数名为PrivateFunc()。我想仔细地同步它们。但是PrivateFunc有时也可以调用PublicFunc，这意味着我们从同一个线程调用它。这会导致阻塞，我想要解决它。
mutable boost::mutex m;
void PublicFunc() {
m.lock();
//Here it blocks, but why?
//What I need is to get the lock if this func was called from PrivateFunc(), so e
浏览 0提问于2012-07-08得票数 4
1回答
如果我有一个具有互斥锁的模块，并且我在互斥锁上使用lock/unlock写一个int变量的值，那么在线程中运行的另一个模块中如何锁定/解锁相同的互斥锁？
外部模块还需要写入变量的值，这是在一个线程循环函数中完成的。如何使用相同的互斥锁来锁定它，还是应该使用另一个互斥锁？
如果两个不同的互斥锁住相同的内存段(不一定同时)，会发生什么？
浏览 0提问于2011-05-10得票数 1
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
腾讯会议
实时音视频活动推荐
腾讯云开发者
