为什么使用boost的并发Hasmap不起作用

Question

我有以下并发哈希图：

template<typename Key, typename Value>
class ConcurrentMap
{

public:
    ConcurrentMap() {};
    bool has(Key k)
    {
        boost::shared_lock<boost::shared_mutex> lock(schemaAccess);
        return m.find(k) != m.end();
    }

    void set(Key k, Value v)
    {
        boost::shared_lock<boost::shared_mutex> lock(schemaAccess);

        // set k, v
        if(m.find(k) != m.end())
        {
            boost::upgrade_lock<boost::shared_mutex> valueLock(*valueAccess[k]);
            boost::upgrade_to_unique_lock<boost::shared_mutex> valueUniqueLock(valueLock);

            m.at(k) = v;
        }
        // insert k, v
        else
        {
            lock.unlock();
            boost::upgrade_lock<boost::shared_mutex> schemaLock(schemaAccess);
            boost::upgrade_to_unique_lock<boost::shared_mutex> schemaUniqueLock(schemaLock);

            boost::shared_ptr<boost::shared_mutex> mtx = boost::make_shared<boost::shared_mutex>();
            valueAccess.insert(std::pair<Key, boost::shared_ptr<boost::shared_mutex> >(k, mtx));
            m.insert(std::pair<Key,Value>(k,v));
        }
    }

    Value get(Key k)
    {
        boost::shared_lock<boost::shared_mutex> lock(schemaAccess);
        return m.at(k);
    }

    bool get(Key k, Value& v)
    {
        boost::shared_lock<boost::shared_mutex> lock(schemaAccess);
        if(m.find(k) != m.end()){
            v = m.at(k);
            return true;
        }
        return false;
    }


private:
    std::map<Key, Value> m;

    std::map<Key, boost::shared_ptr<boost::shared_mutex> > valueAccess;
    boost::shared_mutex schemaAccess;

    //http://stackoverflow.com/questions/36468270/how-to-use-a-boostmutex-as-the-mapped-type-in-stdmap/36469809?noredirect=1#comment60552035_36469809
};

以及以下用法：

ConcurrentMap<int, cv::Mat> mapper;

void worker1(){
    int counter = 0;
    while(1){
        boost::this_thread::sleep(boost::posix_time::milliseconds(5));
        cv::Mat img = cv::Mat(1920,1080, CV_64F);
        cout << "w1" << counter++ << endl;
        mapper.set(0,img);
    }
}

void worker2(){
    int counter = 0;
    while(1){
        boost::this_thread::sleep(boost::posix_time::milliseconds(5));
        cout << "w2" << counter++ << endl;
        cv::Mat img;
        if(!mapper.get(0, img)) continue ;
        cout << img.rows << endl;
        cout << "done" << endl;
    }
}

int main(int argc, char **argv)
{
    ros::init(argc, argv, "loading_area_concat");


    boost::thread worker1_;
    boost::thread worker2_;
    worker1_ = boost::thread(worker1);
    worker2_ = boost::thread(worker2);

    ros::spin();

    return 0;
}

*** Error in `/home/raaj/catkin_ac2/devel/lib/loading_area/loading_area_concat': free(): invalid pointer: 0x00007fb71c000078 ***

然而，我的代码总是在第二个线程的"get“部分崩溃。如果我注释掉"get“，它就会起作用。或者，如果我用下面的代码完全锁定get代码，它就能正常工作：

    boost::upgrade_lock<boost::shared_mutex> schemaLock(schemaAccess);
    boost::upgrade_to_unique_lock<boost::shared_mutex> schemaUniqueLock(schemaLock);

我似乎不明白为什么会发生这样的事情。当我在哈希图中写那个键的时候，我锁定了它，当我读它的时候，写入器不应该进来破坏内存，是吗？

Answer 1

您是否也尝试过锁定get()并检查问题是否消失了？从高层次的观点来看，只有在没有写入的情况下，读取才不需要被锁定。如果有一些线程对该位置进行写操作，那么读操作也需要受到保护，否则会出现竞争条件(get()可能会使用不再有效的内容)。

好的，我看到了get()中的锁定解决了这个问题，所以看起来确实是这样的。

问题是，不变内存的并发读取不需要被锁定。但是如果有并发写操作，那么读操作也需要被锁定(相对于写操作，否则可能会发生各种奇怪的事情，比如部分/交错读，等等)。