c++ - boost::interprocess 锁的持久性

我有以下崩溃的代码。我怀疑这是因为我对这个问题分配了对堆栈的引用。但我想避免每次都要堆叠分配互斥锁和作用域锁的成本

 class Cache {
  public:
    void createCacheLock(const char* name) {
       named_mutex mutex_(open_only, name);
       mutex = &mutex_;
       scoped_lock<named_mutex> cache_lock_(mutex_, defer_lock);
       cache_lock=&cache_lock_ ;

   }

 void updateCache(const char* name, int newvalue) {
             cache_lock->lock()  ;
             /* Do update work */
             cache_lock->unlock() ;
 }

 private:
     named_mutex* mutex ;
     scoped_lock<named_mutex>* cache_lock;


 }

然后，我存在该函数(cache_lock是一个类字段)，当尝试从其他类方法中调用cache_lock.lock时，我的程序崩溃了(在这种情况下，updateCache在cache_lock-> lock()部分崩溃了)

我有两个问题:如何创建“持久” cache_lock，以便无需调用named_mutex(open_only等)就可以重用它？
ak我想避免每次都这样做

void updateCache(const char* name, int newvalue) {
        named_mutex mutex_(open_only, name);
        scoped_lock<named_mutex> cache_lock_(mutex_, defer_lock);
        /* Do update work */
         cache_lock->unlock() ;

}

其次，重复上述过程(即查找互斥对象并从中创建锁)是一项昂贵的操作吗？

最佳答案

您具有指向局部变量的指针。局部变量仅在函数运行时才在堆栈上存在，当函数返回时，这些对象将被销毁并调用其析构函数。这些对象占用的内存将在函数返回后由下一个要调用的函数重用。这意味着您拥有的指针不仅指向可能被破坏的对象，还可以指向用于完全不同的内存的指针。当然，引用也一样。

而是使用new在堆上分配这些对象，或使用smart pointers。

您可以在构造函数初始化器列表中调用类中对象的特定构造函数:

class cache
{
public:
    cache(const std::string& lock_name)
        : mutex_(open_only, lock_name),
          cache_lock_(mutex_, defer_lock)
        {}

    // ...

private:
    named_mutex mutex_;
    scoped_lock<named_mutex> cache_lock_;

    // ...
};

关于c++ - boost::interprocess 锁的持久性，我们在Stack Overflow上找到一个类似的问题：https://stackoverflow.com/questions/14356089/