1

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

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

}

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

4

1 回答 1

3

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

而是在堆上分配这些对象new，或者使用智能指针。

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

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

    // ...
};
于 2013-01-16T11:11:23.837 回答