2回答
在Mac上的boost land中，下面的代码本身会锁住：
boost::mutex m;
m.lock();
m.lock();
同样的情况也适用于
boost::mutex m;
boost::mutex::scoped_lock lock(m);
boost::mutex::scoped_lock lock(m);
在Windows中，只要释放计数相同，相同的线程就可以得到它想要的Win32互斥量。我需要一个boost同步对象的确切行为。
浏览 0提问于2013-09-03得票数 0
回答已采纳
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
回答已采纳
2回答
分配给我的任务是使用POSIX线程编写读写实现。我想知道，对于这两种情况，我的实施是否正确：
恐怖企图抹去了
第2次尝试
阅读器首选：
变量：
int readersActive_;
sem_t lock_;
sem_t writeLock_;
执行情况：
void PalindromeDatabase::lockReaders()
{
sem_wait(&lock_);
{
++readersActive_;
if (readersActive_ == 1)
sem_wait(&writeLock_)
浏览 0提问于2011-12-20得票数 0
2回答
因此，假设一个线程，线程通过以下方式获得一个锁：
pthread_mutex_lock(&lock);
然后，在解锁之前，它再次到达一行，即：
pthread_mutex_lock(&lock);
线程库会阻止线程的进程，还是会识别线程已经持有锁，从而允许它通过？
浏览 3提问于2017-11-12得票数 3
回答已采纳
从问题中，我了解到std::scoped_lock是“std::lock_guard的一个严格的高级版本”。
从问题中，我了解到"std::lock_guard和std::unique_lock是相同的“，除了std::unique_lock有一些额外的特性(例如。( )，以额外的开销为代价。
std::scoped_lock 与 std::unique_lock**?**相比如何？
一些相关的问题，我希望得到这个问题的答案。
std::unique_lockIn和std::scoped_lock的区别是什么情况应该使用std::scoped_lock而不是std::unique_lo
浏览 7提问于2019-10-18得票数 34
回答已采纳
结构或链表中的互斥变量是如何实际生效的。它会锁定整个结构吗？实际上，当它在一个结构中声明时，它是如何工作的呢？它工作的内部细节是什么？ 下面是一个来自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
3回答
“互斥”和“锁”有什么区别？
、、、、
我对锁和互斥之间的区别感到非常困惑。在助推文档里，它说，
锁类型
类模板lock_guardClass模板unique_lockClass模板shared_lockClass模板upgrade_lockClass模板upgrade_to_unique_lockMutex-specific类scoped_try_lock
互斥类型
mutexTypedef try_mutexClass timed_mutexClass recursive_mutexTypedef recursive_try_mutexClass recursive_timed_mutexClass shared_mutex类
浏览 2提问于2012-02-21得票数 27
回答已采纳
1回答
好的。这里的示例是使用c中的pthread提供的。
在教科书中，我看到了以下代码：
//for thread 2
pthread_mutex_lock(&lock);
should_wake_up = 1;
pthread_cond_signal(&cond);
pthread_mutex_unlock(&lock);
这段代码很好用。我只是想知道下面的代码也能工作吗？
//for thread 2
pthread_mutex_lock(&lock);
should_wake_up = 1;
pthread_mutex_unlock(&lock);
pt
浏览 0提问于2020-03-01得票数 3
回答已采纳
我对线程有些陌生，我正试图了解它在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
我想知道以下两种方法的区别：
boost::timed_mutex _mutex;
if(_mutex.timed_lock(boost::get_system_time() + boost::posix_time::milliseconds(10))){
exclusive code
_mutex.unlock();
}
和
boost::timed_mutex _mutex;
boost::timed_mutex::scoped_lock scoped_lock(_mutex, boost::get_system_time() + boost::posix_time::mill
浏览 2提问于2014-06-16得票数 1
回答已采纳
我想问一下，是否可以使用1个条件变量与2个互斥锁关联，用于2种数据更新。
基本上，我有thread1和thread2。Thread1可以等待2种类型的数据更新，所以它有2个互斥锁，每个互斥锁一个。(我知道我可以使用一个互斥锁来处理所有这些数据，但这不是这个问题的重点，对吧？)我当然不希望它在data2已经可用的时候等待data1，所以它只有一个条件变量。thread2将同时提供data1和data2。问题是，在thread2中，我不知道thread1现在是在等待data1还是data2，或者根本不等待。
伪代码将如下所示：
global data:
cond_var
mutex
浏览 0提问于2012-10-18得票数 3
回答已采纳
我有一个函数，如下所示:线程使用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
回答已采纳
void wait(int seconds)
{
boost::this_thread::sleep(boost::posix_time::seconds(seconds));
}
boost::timed_mutex mutex;
void thread()
{
for (int i = 0; i < 5; ++i)
{
wait(1);
boost::unique_lock<boost::timed_mutex> lock(mutex, boost::try_to_lock);
if (!lock.owns_
浏览 0提问于2013-01-08得票数 2
回答已采纳
1回答
我遇到了存储在实例中的互斥对象的问题。举个例子，我写道：
#include <iostream>
#include <mutex>
#include <shared_mutex>
#include <thread>
#include "Sleep.h"
struct Test
{
std::shared_mutex mutex;
};
Test* test = new Test();
void t1()
{
std::unique_lock<std::shared_mutex> lock(test
浏览 2提问于2016-10-13得票数 2
回答已采纳
我正在使用scoped_lock和mutex实现一个版本的，但是在boost中有多个不同的预编译头文件。
scoped_lock可以通过"boost/interprocessor/sync/scoped_lock.hpp“和"boost/thread/mutex.hpp”获得
mutex可以通过"boost/thread/mutex.hpp“、"boost/signals2/mutex.hpp”和"boost/thread/win32/mutex.hpp“获得。
我可以猜到"win32/mutex.hpp“在某种程度上针对windows进行了优化
浏览 3提问于2011-10-26得票数 1
回答已采纳
2回答
我正在尝试解决C++11中的生产者和消费者问题，我有一个保存资源的对象，多线程可以添加或消费这些资源。我的问题是，当我试图在该对象上实现“当可用时使用”方法时。请假设插入/删除操作的复杂性微不足道。
稍微解释一下代码中的逻辑。
struct ResourceManager{
std::mutex mux;
std::unique_lock lock{mux};
std::condition_variable bell;
void addResource(/*some Resource*/){
lock.lock();
//add resource
lo
浏览 3提问于2017-06-16得票数 2
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
请参阅下列经典生产者-消费者代码：
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
回答已采纳
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回答
在多线程环境中实现malloc
、、、、
我想在多线程环境中实现malloc，我从获得了代码。
添加互斥锁后：
typedef struct free_block {
size_t size;
struct free_block* next;
pthread_mutex_t lock;
} free_block;
void free_block_init(free_block *FB){
pthread_mutex_init(&FB->lock, NULL);
}
static free_block free_block_list_head = { 0, 0 };
static con
浏览 6提问于2014-10-05得票数 2
在我的测试程序中，我启动了两个线程，每个线程只执行以下逻辑：
1) pthread_mutex_lock()
2) sleep(1)
3) pthread_mutex_unlock()
但是，我发现一段时间后，两个线程中的一个将在pthread_mutex_lock()上永久阻塞，而另一个线程正常工作。这是一种非常奇怪的行为，我认为这可能是一个潜在的严重问题。通过Linux手册，在获取pthread_mutex_t时并不禁止使用sleep()。所以我的问题是:这是一个真正的问题，还是我的代码中有任何bug？
以下是测试程序。在代码中，第一个线程的输出被定向到stdout
浏览 1提问于2011-11-11得票数 4
谈到
我可以为critical section使用static mutex，如下所示：
#include <string>
#include <mutex>
#include <iostream>
#include <fstream>
#include <stdexcept>
void write_to_file (const std::string & message) {
// mutex to protect file access
static std::mutex mutex;
// lo
浏览 1提问于2015-03-03得票数 3
对于条件变量是如何工作的(在共享数据并发访问方面)，我有点困惑。
下面是伪C代码来说明我当前的问题
// Thread 1: Producer
void cakeMaker()
{
lock(some_lock);
while(number_of_cakes == MAX_CAKES)
wait(rack_has_space);
number_of_cakes++;
signal(rack_has_cakes);
unlock(some_lock);
}
// Thread 2: Consumer
void cakeEater()
浏览 3提问于2017-12-14得票数 8
回答已采纳
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回答
Java嵌套同步
、、
我有一个问题需要理解嵌套同步是如何工作的。我在这里举两个例子作比较：
//example 1
public class Account {
int balance = 1000;
Object lock = new Object();
public int getBalance() throws InterruptedException {
synchronized(lock) {
// step 1- Thread 1 enter here and sleep
Thread.sleep(20);
浏览 0提问于2014-05-13得票数 3
回答已采纳
我的PTHREAD_MUTEX_RECURSIVE有以下问题:当互斥锁从另一个线程锁定时，它会阻塞；
pthread_mutex_t m;
pthread_mutexattr_t ma;
void* exec_th(void* arg) {
printf("THREAD %p before LOCK\n", pthread_self());
//second mutex lock
pthread_mutex_lock(&m);
printf("THREAD %p after LOCK\n", pthread_self(
浏览 0提问于2018-05-02得票数 2
回答已采纳
退出空闲线程的实现如下：
int tp_delete_thread(TpThreadPool *pTp) {
unsigned idx;
TpThreadInfo *pThi;
TpThreadInfo tT;
//current thread num can't < min thread num
if (pTp->cur_th_num <= pTp->min_th_num)
return -1;
//all threads are busy
pThi = (TpThreadInfo *)
浏览 1提问于2014-03-14得票数 0
1回答
在此示例中，使用标志std::defer_lock调用std::unique_lock。在cppreference上写道："defer_lock_t不获取互斥锁的所有权“和：”(析构函数)解锁关联的互斥锁，如果拥有“
现在，问题来了！
为什么在本例中，std::unique_lock在析构函数中调用解锁？
void transfer(Box &from, Box &to, int num)
{
// don't actually take the locks yet
std::unique_lock<std::mutex> lock1
浏览 18提问于2016-07-23得票数 1
回答已采纳
以下代码挂起是因为需要多次调用才能获得非递归互斥体：
#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
回答已采纳
1回答
我有Get()和Set()方法，我想让它们成为线程安全的。我想知道我是否应该使用两个互斥锁，一个用于Get，另一个用于Set，或者我可以使用一个互斥锁，如下面的代码所示。 public:
float Get(string name){
lock_guard<mutex> lock(mutex1);
return value_map[name];
}
Set(string name, float value){
lock_guard<mutex> lock(mutex1);
value_map[name] = value;
}
private:
ma
浏览 13提问于2019-01-03得票数 0
回答已采纳
3回答
我正在尝试理解为什么我的互斥锁的行为不像我所期望的那样。
我正在调试另一个问题，并决定制作一个非常简单的可执行文件来直接测试互斥行为。这是我想出来的：
#include <mutex>
#include <thread>
#include <iostream>
#include <chrono>
int main(int argc, char** argv)
{
std::mutex myMutex;
auto threadGenerator = [&] (std::string printout)
浏览 0提问于2017-03-08得票数 3
以下是我的代码
#include <iostream>
#include <mutex>
#include <shared_mutex>
#include <thread>
#include <windows.h>
using namespace std;
class Counter {
public:
Counter() : value_(0) {
}
// Multiple threads/readers can read the counter's value at the same time
浏览 0提问于2020-04-29得票数 0
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
回答已采纳
我正在模拟一个设备，当时钟具有下降沿时，该设备将接收字节数据并写入寄存器。我已经创建了一个独立的pthread来解决时钟在高和低之间移动的问题。
现在我的问题是，在主线程中，我让控制台要求用户输入十六进制值以写入“设备”，然后它调用一个SendCommand(uint32_t addr，uint16_t data)函数来执行此操作。因为它应该在每个时钟周期内一次发送一个比特，所以我将它放在for循环中。下面是send命令函数：
void SendCmd(uint32_t loadAddr, uint16_t data)
{
dest = &loadAddr;
int i
浏览 3提问于2014-10-10得票数 0
1回答
我不知道这是不是很好的做法，但我正在对输入数据流进行实时处理，并以锁步顺序使用pthread，以允许一次一个线程同时执行不同的操作。这是我为每个线程编写的程序流程：
void * my_thread() {
pthread_mutex_lock(&read_mutex);
/*
read data from a stream such as stdin into global buffer
*/
pthread_mutex_lock(&operation_mutex);
pthread_mutex_unlock(&re
浏览 0提问于2018-08-06得票数 0
我在试着理解condition_variables。
我想我的代码应该像：
主锁mx
主等待()通知<=此处已释放锁
线程锁mx
线程发送通知
线程解锁mx
主等待()完成并锁定mx
那么，为什么线程能够比通知后的wait()调用更快地锁定mx呢？
#include <iostream>
#include <future>
#include <condition_variable>
#include <vector>
using namespace std::chrono_literals;
std::
浏览 2提问于2017-05-09得票数 0
回答已采纳
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回答
我正在研究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
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
回答已采纳
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回答
给定线程TA和TB在下面的f()中竞争：
struct C {
C(): a(0) {}
int a;
std::mutex mtx;
void f() {
... // use 'a' in readonly mode
std::lock_guard<std::mutex> lock(mtx); // assume TA gets the lock first, then TB
a += 2; // what value of 'a' will TB see?
}
}
在获取锁时，TB如何知道他缓存的&#
浏览 0提问于2013-01-10得票数 1
回答已采纳
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
回答已采纳
我在读关于互斥的文章。它说
lock_guard和unique_lock最大的区别在于，lock_guard总是拥有引用的互斥锁模式，而unique_lock不拥有。实际上，unique_lock甚至可能不引用互斥锁。
到目前为止，我只知道当我们需要构造一个锁，而不是锁定互斥锁时，我们可以使用std::unique_lock。这是一个改进版的std::lock_guard，除了我看不出有多大的区别。如果有人能解释拥有引用互斥体的锁模式意味着什么，我将不胜感激。
浏览 1提问于2013-10-17得票数 1
回答已采纳
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回答
我正在阅读Effective C++，在Rule 14: Think carefully about copying behavior in resource-managing classes中，有一个例子：
class Lock {
public:
explicit Lock(Mutex* pm) : mutexPtr(pm) {
lock(mutexPtr);
}
~Lock() {
unlock(mutexPtr);
}
private:
Mutex *mutexPtr;
};
它指出，如果我们像上面那样构造Lock
浏览 1提问于2017-12-11得票数 0
1回答
我最近开始使用boost::thread (WinXP，VS10，BoostPro)，发现互斥锁可以被任何线程解锁，而不是只由拥有它的线程解锁。此外，它看起来像是基本的lock_guard +互斥组合正在执行多个lock()和unlock()的一些内部计数，但我想这不是一个大问题。
有人知道为什么它是这样设计的吗？这是故意的吗？(或者我的构建环境/库可能有问题？)
示例应用程序：
#include <iostream>
#include <boost/thread.hpp>
using namespace std;
class NamedThread
{
publ
浏览 3提问于2011-09-10得票数 1
回答已采纳
我有一个运行三个线程的应用程序。这三个线程都在根据全局变量的状态执行一些操作。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
互斥对象引用的互斥对象将通过调用pthread_mutex_lock()来锁定。如果互斥锁已锁定，则调用线程将阻塞，直到互斥锁可用为止。此操作将以互斥对象在锁定状态下引用的互斥对象返回，调用线程作为其所有者。
我的问题是，如果互斥锁已经锁定，并且我们调用了pthread_mutex_lock()，那么这个函数是在线程被阻塞的情况下返回值，还是在块之后返回值？
说明我的问题。
互斥锁被第一线程锁定。
第二个线程试图用pthread_mutex_lock()锁定这个互斥对象。
会发生什么？pthread_mutex_lock()何时将其值返回给第二个线程？
是在互斥
浏览 2提问于2021-09-13得票数 0
回答已采纳
下面我有一个问题。
Process A Process B
int A = 0; int B = 0;
pthread_mutex_lock(&mutex);
while (condition == FALSE)
pthread_cond_wait(&cond, &mutex);
pthread_mutex_lock(&mutex);
浏览 0提问于2015-03-02得票数 0
1回答
使用下面的互斥锁示例有意义吗?还是应该先解锁“A”，然后再锁定“B”？
mtx.lock(A);
mtx.lock(B);
//code
mtx.unlock(A);
mtx.unlock(B);
如果我像描述的那样使用它，会出现什么问题？
浏览 2提问于2020-10-21得票数 0
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
即时通信 IM
实时音视频活动推荐
腾讯云开发者
