提高进程间锁持久性

Boost Interprocess Lock persistence

本文关键字：持久性 进程 高进程      更新时间：2023-10-16

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

 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时。我的程序崩溃(在本例中，updateCache在cache_lock->lock()部分崩溃)

我有两个问题:我如何创建一个"持久"的cache_lock，这样我就可以重用它，而不需要调用named_mutex (open_only等)?我想避免每次都这样做

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代替在堆上分配这些对象，或者使用智能指针。

可以在构造函数初始化列表:

中调用类中对象的特定构造函数
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_;
    // ...
};
相关文章：