C++中的线程安全、有序映射/哈希

Threadsafe, ordered mapping/hash in C++?

这是一个基本问题，即在没有内存回收机制的情况下，很难同时在一个并发数据结构中融合快速遍历和安全擦除属性，您必须在这里选择：安全性/一致性或速度。

在一定的限制和谨慎的情况下，您可以像本博客中描述的那样同时进行遍历和删除。基本上，它说只要你能交错（互斥）遍历和擦除，tbb::concurrent_hash_map就可以和find&插入博客建议使用双重检查模式进行额外的优化。但它可以简化为以下内容：

for(iterator = table.begin(); iterator != table.end(); iterator++ ) {
    accessor acc;
    // a key cannot be changed thus it is safe to read it without lock
    table.find( acc, iterator->first );   // now get the get the lock
    if( acc->second.market_for_deletion )
        table.erase( acc );               // erase only by accessor
}

它本质上类似于应用于concurrent_hash_map情况的注释2，因为最大的开销不是来自查找（对于相邻元素，缓存未命中的可能性较小），而是来自与两个锁（内部bucket的锁和元素的访问器）的同步。

但是，如果这种遍历方法的速度太慢，或者对您来说太麻烦（取决于实现细节），但您仍然迫切需要能够删除并发哈希表的元素，那么可以考虑使用像tbb::spin_rw_mutex和tbb::concurrent_unordered_map这样的RW锁。您需要找到一个最佳的位置，在那里可以不太频繁地获取读锁，以启用迭代、查找和；在没有太多开销的情况下插入，并且在写锁定下进行擦除也不太频繁。可能它需要额外的方案来标记和收集足够的元素，然后才能真正删除它们。例如，下面是这样一个哈希表类的伪代码：

class concurrent_hash_table_with_erase_and_traverse {
    tbb::concurrent_unordered_map my_map;
    tbb::spin_rw_mutex            my_lock; // acquired as writer for cleanup only
    tbb::atomic<size_t>           my_trash_count; // indicates # of items for erase
public:
    void init_thread_for_concurrent_ops() { my_lock.lock_read(); }
    void release_thread()                 { my_lock.unlock(); } // assuming reader lock
    mapped_type read(key_type k) {
        // assert: under read lock (thread is initialized)
        if(my_trash_count > threshold) {  // time to remove items
            my_lock.unlock(); // release reader
            // waiting all the threads to enter this container
            // TODO: re-implement with try_lock and checking the condition 
            my_lock.lock();   // acquire writer
            if(my_trash_count > threshold) { // double-check
                my_trash_count = 0;
                for( auto it = my_map.begin(); it != my_map.end(); ) {
                    auto _it = it++;
                    if( _it->is_marked_for_erase )
                        my_map.unsafe_erase( _it );
                }
            }
            my_lock.unlock();    // release writer
            my_lock.lock_read(); // acquire reader
        }
        return my_map[k]; // note: access is not protected like in concurrent_hash_map
    }
    void safe_erase(key_type k) {
        // assert: under read lock
        my_map[k].is_marked_for_erase = true;
        my_trash_count++;
    }
};

template<typename kType, typename dType>
class Locked {
  std::mutex mut;
  std::map<kType, dType> theMap; // change types as required
public:
  const dType get(const kType& key) const {
    std::lock_guard<std::mutex> g(mut);
    auto it = theMap.find(key);
    if (it != theMap.end())
      return *it;
    // throw or return buggy dType
    return dType(-1); // or whatever
  }
  void set(const kType& key, const dType& data) {
    std::lock_guard<std::mutex> g(mut);
    theMap[key] = data;
  }
  void delete(const kType& key) {
    std::lock_guard<std::mutex> g(mut);
    auto it = theMap.find(key);
    if (it != theMap.end()) {
      theMap.erase(it);
      return;
    }
    // throw?
  }
}