Question

我用dll编写了一个Visual c++ in Visual Studio 2008，由多个进程和线程使用。

场景是这样的：

一个编写程序进程调用＆＃34; init＆＃34;在dll的方法中，此方法创建共享内存并在共享内存中创建boost multi_index容器，并通过调用其insert方法开始推送数据。

创建容器后，最多有10个阅读器应用程序通过调用搜索方法开始在其中执行搜索操作。

经过一段时间后（让我们说30秒），编写进程会创建一个删除线程，开始删除容器中的数据（最旧的），其频率类似于1次删除操作/秒。

代码的头文件（hpp）如下所示：

class SharedMemoryContainer
{     

private:

    typedef boost::interprocess::allocator<SharedObj, managed_shared_memory::segment_manager> ShmemAllocator;

    typedef multi_index_container<
        SharedObj, 
            indexed_by<    
                random_access<>, 
                ordered_non_unique< member<SharedObj, unsigned _int64, &SharedObj::id >
            >, ShmemAllocator
    > SharedMemoryContainerType;


    struct compare
    {
        unsigned _int64 _compare; 
        int _trackNo;
        compare(unsigned _int64 id, int trackNo) : _compare(id), _trackNo(trackNo) {}
        bool operator()(SharedObj const& item) const {return (item.id == _compare && item.trackNo == _trackNo);};
    };


    static boost::mutex mutex_; // the mutex that i used to synchronize the operations

    /*
    .
    .
    some more variables and methods...
    .
    .
    */

public:

    bool insert (/*.. parameters ..*/); 

    SharedObj search (/*.. parameters ..*/);

    bool delete ();

    /*
    .
    .
    some more variables and methods...
    .
    .
    */
};

在实现（cpp）文件中，我使用这样的互斥：

boost::mutex SharedMemoryContainer::mutex_; // for the static mutex

// insert new data to shared container
bool SharedMemoryContainer::insert(/*.. parameters ..*/) 
{
    boost::mutex::scoped_lock m(mutex_);
    bool result;
        try
        {
            // Make the insertion here
        }
        catch(interprocess_exception &ex)
        {
            std::cout << "Error in Insert!" << std::endl <<ex.what() << std::endl;
            return false;
        }
    return result;
}

// reader applications perform search in shared container
SharedObj SharedMemoryContainer::search(/*.. parameters ..*/) 
{
    boost::mutex::scoped_lock m(mutex_);

    IndexType& idIndex = myContainer->get<0>();
    IteratorType current = std::find_if(idIndex.begin(), idIndex.end(), compare(id, trackNo));
    /*
    .
    .
    other operations
    .
    .
    */
}

// it always delete the oldest one
bool SharedMemoryContainer::delete() 
{
    boost::mutex::scoped_lock m(mutex_);

    IndexType& idIndex = myContainer->get<0>();
    it first = myContainer->begin();            
    idIndex.erase(first); 
}

这种互斥用法似乎无效。因为它总是在不同的时间崩溃（我的意思是它会改变，它可以在40秒或5分钟之后等等）。

它在compare struct（在search - find_if中调用）与"access violation unable to read location ..."崩溃，因为删除线程改变了我猜的容器（没有删除线程就可以正常工作）

如何保持我的共享multi_index容器线程/进程安全且同步？

...谢谢

修改

我还有一个关于互斥锁工作逻辑的问题。

就我读取互斥锁而言，只需锁定代码以防止多次进入代码块而不是容器本身。例如，在上面的代码中，当读者应用程序进入＆＃34;搜索＆＃34;方法和锁定容器没有其他读者应用程序可以输入代码，但删除线程也可以通过输入＆＃34;删除＆＃34;方法并更换容器？

那么如何一次阻止一个共享容器上的多个操作？

Answer 1

如果您read this link第一段说明：

在DLL源代码文件中声明为全局的变量被编译器和链接器视为全局变量，但是加载给定DLL的每个进程都会获得该DLL的全局变量的副本。静态变量的范围仅限于声明静态变量的块。因此，默认情况下，每个进程都有自己的DLL全局变量和静态变量。

这意味着使用您的DLL的每个进程都将拥有它自己的单独的和非共享互斥锁副本。因此，即使两个进程共享容器，互斥锁也将是独立的，不会共享导致数据争用。

Answer 2

由于您已经将boost作为依赖项，因此最好的做法是开始使用进程间库中的互斥锁。手册和示例（here）。

确保始终使用定时锁定，否则如果读取器或写入器在保持整个系统死锁时崩溃。

如何在c ++中使共享内存线程中的容器安全

2 个答案: