c++ - 从析构函数中释放 boost::mutex-6ren

c++ - 从析构函数中释放 boost::mutex

转载作者：太空宇宙更新时间：2023-11-04 12:13:20

由于 std::vector 不是线程安全的，我试图围绕它构建一个非常简单的封装，使其成为线程安全的。

这工作得很好，但有一个小问题。当类的实例正在被破坏并且另一个线程仍在尝试从中读取数据时，该线程将永远卡在 boost::mutex::scoped_lock lock(m_mutex);

我该如何解决这个问题？最好的办法是只解锁互斥量，以便卡在其中的线程可以继续执行。我没有定义析构函数，因为直到现在，它还不是必需的。

这是我的代码。请注意，这里显示的方法比这里显示的要多，它已经过简化。

template<class T>
class SafeVector 
{
    public:
    SafeVector();
    SafeVector(const SafeVector<T>& other);

    unsigned int size() const;
    bool empty() const;

    void clear();
    T& operator[] (const unsigned int& n);

    T& front();
    T& back();

    void push_back(const T& val);
    T pop_back();

    void erase(int i);

    typename std::vector<T>::const_iterator begin() const;
    typename std::vector<T>::const_iterator end() const;

    const SafeVector<T>& operator= (const SafeVector<T>& other);

    protected:
    mutable boost::mutex m_mutex;
    std::vector<T>  m_vector;

};

template<class T>
SafeVector<T>::SafeVector()
{

}

template<class T>
SafeVector<T>::SafeVector(const SafeVector<T>& other)
{
    this->m_vector = other.m_vector;
}

template<class T>
unsigned int SafeVector<T>::size() const
{
    boost::mutex::scoped_lock lock(m_mutex);
    return this->m_vector.size();
}

template<class T>
bool SafeVector<T>::empty() const
{
    boost::mutex::scoped_lock lock(m_mutex);
    return this->m_vector.empty();
}

template<class T>
void SafeVector<T>::clear()
{
    boost::mutex::scoped_lock lock(m_mutex);
    return this->m_vector.clear();
}

template<class T>
T& SafeVector<T>::operator[] (const unsigned int& n)
{
    boost::mutex::scoped_lock lock(m_mutex);
    return (this->m_vector)[n];
}

template<class T>
T& SafeVector<T>::front()
{
    boost::mutex::scoped_lock lock(m_mutex);
    return this->m_vector.front();
}

template<class T>
T& SafeVector<T>::back()
{
    boost::mutex::scoped_lock lock(m_mutex);
    return this->m_vector.back();
}

template<class T>
void SafeVector<T>::push_back(const T& val)
{
    boost::mutex::scoped_lock lock(m_mutex);
    return this->m_vector.push_back(val);
}

template<class T>
T SafeVector<T>::pop_back()
{
    boost::mutex::scoped_lock lock(m_mutex);
    T back = m_vector.back();
    m_vector.pop_back();
    return back;
}

template<class T>
void SafeVector<T>::erase(int i)
{
    boost::mutex::scoped_lock lock(m_mutex);
    this->m_vector.erase(m_vector.begin() + i);
}

template<class T>
typename std::vector<T>::const_iterator SafeVector<T>::begin() const
{
    return m_vector.begin();
}

template<class T>
typename std::vector<T>::const_iterator SafeVector<T>::end() const
{
    return m_vector.end();
}

编辑我必须更改我的定义。如前所述，容器显然不是线程安全的。它不应该这样做——即使术语具有误导性。当然，您可以用它做一些根本不是线程安全的事情!但是只有一个线程写入容器，2 或 3 个线程从中读取。在我尝试停止该过程之前，它运行良好。我不得不说显示器会更好。但时间不多了，我不能在那之前改变这一点。

任何想法表示赞赏!谢谢和问候。

最佳答案

编辑:更新为更完整的示例。

其他人指出了您的“线程安全”的缺陷；我会尝试回答您的问题。

要完成您计划要做的事情，唯一正确的方法是确保在尝试销毁 vector 本身之前关闭所有线程。

我用过的一个常用方法是简单地使用 RAII定义构造和破坏的顺序。

void doSomethingWithVector(SafeVector &t_vec)
{
  while (!boost::this_thread::interruption_requested())
  {
    //operate on t_vec
  }
}

class MyClassThatUsesThreadsAndStuff
{
  public:
    MyClassThatUsesThreadsAndStuff()
      : m_thread1(&doSomethingWithVector, boost::ref(m_vector)),
        m_thread2(&doSomethingWithVector, boost::ref(m_vector))
    {
      // RAII guarantees that the vector is created before the threads
    }

    ~MyClassThatUsesThreadsAndStuff()
    {
      m_thread1.interrupt();
      m_thread2.interrupt();
      m_thread1.join();
      m_thread2.join();
      // RAII guarantees that vector is freed after the threads are freed
    }

  private:
    SafeVector m_vector;
    boost::thread m_thread1;
    boost::thread m_thread2;
};