从地图擦除时崩溃

Question

由于意外行为，我发生了崩溃。我想问一下如何修改代码以防止发生的崩溃。

   void SubscManag::handleNotif(Notif notif)
    {
   
        std::cout << "Current subscribe size: " << subs_.size();
        std::map<int, SubscData>::iterator it;
        {
            std::lock_guard<std::recursive_mutex> lock(mutex_);
            it = subs_.begin();
        }
        for (;;)
        {
            std::lock_guard<std::recursive_mutex> lock(mutex_);
            if (it == subs_.end())
            {
                break;
            }
            if (it->second.hasToBeErased)
            {
                std::cout << "Erase id : " << it->first;
                it = subs_.erase(it);
                continue;
            }
            if (cond)
            {
                // ....
                ++it;
                continue;
            }
            // ....
            ++it;
        }
    }

崩溃发生在 it = subs_.erase(it); 有了这个

 Erase id : 2
 Erase id : 3
 Erase id : 28473456

所以Element with id : 28473456 可能不存在或已损坏，但我该如何防御崩溃？ 谢谢。

Answer 1

你正在尝试做基于锁的并发。

基于锁的并发不构成。本地正确的操作在连接时会产生垃圾。

这里的问题是你的it是在一个锁中生成的，然后你解锁。在解锁期间，it 可能有效也可能无效。然后你重新锁定并假设it 仍然有效。

您要么必须锁定您在地图上工作的整个时间段，然后解锁它并忘记锁定中您所知道的几乎所有内容（不携带迭代器），根据不可变数据结构重写您的代码，或者执行其他更激进的东西。

{
  std::lock_guard<std::recursive_mutex> lock(mutex_);
  it = subs_.begin();
}

你在这里锁定，做一个操作，然后......在作用域的末端解锁互斥锁。

所以it 是映射到地图的迭代器，当您持有它时，您不会阻止其他线程编辑地图。这可能会使it 无效。

同样的事情发生在你的for(;;) 循环中；您在每次迭代开始时锁定，然后在结束时解锁。 it 引用的地图元素可能会被删除，从而使您的 it 在一次迭代和下一次迭代之间失效。

这是一个简单的实用程序类：

template<class T>
struct mutex_guarded {
  template<class F>
  auto read(F&& f)const {
    auto l = std::unique_lock<std::mutex>(m);
    return f(t);
  }
  template<class F>
  auto write(F&& f) {
    auto l = std::unique_lock<std::mutex>(m);
    return f(t);
  }
private:
  mutable std::mutex m;
  T t;
};

现在，将您的 std::map<int, SubscData> 更改为 mutex_guarded<std::map<int, SubscData>>。

下一步：

void SubscManag::handleNotif(Notif notif)
{
  subs_.write([&](auto& subs_) {
    std::cout << "Current subscribe size: " << subs_.size();
    auto it = subs_.begin();
    for (;;)
    {
        if (it == subs_.end())
        {
            break;
        }
        if (it->second.hasToBeErased)
        {
            std::cout << "Erase id : " << it->first;
            it = subs_.erase(it);
            continue;
        }
        if (cond)
        {
            // ....
            ++it;
            continue;
        }
        // ....
        ++it;
      }
  });
}

您将在访问 subs_ 时锁定互斥锁。

请注意，通过其他方法访问subs_ 仍然很危险。使用互斥锁保护单个方法调用是一个糟糕的计划。让“这个对象可以从任何线程访问”是 999/1000 案例中的灾难，通常会延迟，最初的小案例工作，然后在编写代码很长时间后，它会在死锁和竞争条件下爆炸。

mutex_guarded 不是最好的解决方案，但它比按方法锁定要好。