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

Question

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

 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() ; 

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

Answer 1

你有指向局部变量的指针。局部变量仅在函数运行时存在于堆栈中，当函数返回时，这些对象被销毁并调用它们的析构函数。这些对象占用的内存将在函数返回后被下一个要调用的函数重用。这意味着您拥有的指针不仅指向可能被破坏的对象，还可以指向内存用于完全不同的东西。当然，引用文献也是如此。

使用 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_;

    // ...
};