1

由于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 个线程从中读取。在我尝试停止该过程之前，它运行良好。我不得不说显示器会更好。但是时间不多了，在那之前我无法改变这一点。

任何想法表示赞赏！谢谢并恭祝安康。

4

1 回答 1

1

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

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

做你打算做的事情的唯一正确方法是在你尝试销毁向量本身之前确保所有线程都已关闭。

我使用的一个常用方法是简单地使用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;
};

如果您正在寻找允许多个读取器和写入器的更完整的线程安全数据结构，请随时查看我使用 boost 线程编写的队列。

http://code.google.com/p/crategameengine/source/browse/trunk/include/mvc/queue.hpp

于 2012-01-15T04:17:44.747 回答