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-＆gt; 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_;

    // ...
};

提升进程间锁定持久性

1 个答案: