c++ - 另一个线程安全队列实现

Question

我有一个类 Queue，我试图使它成为线程安全的。它有这三个成员变量:

    std::queue<T>   m_queue;
    pthread_mutex_t m_mutex;
    pthread_cond_t  m_condition;

和一个推送和弹出实现为:

    template<class T> void Queue<T>::push(T value)
    {
        pthread_mutex_lock( &m_mutex );
        m_queue.push(value);
        if( !m_queue.empty() )
        {
            pthread_cond_signal( &m_condition );
        }
        pthread_mutex_unlock( &m_mutex );
    }

    template<class T> bool Queue<T>::pop(T& value, bool block)
    {
        bool rtn = false;
        pthread_mutex_lock( &m_mutex );
        if( block )
        {
            while( m_queue.empty() )
            {
                pthread_cond_wait( &m_condition, &m_mutex );
            }
        }
        if( !m_queue.empty() )
        {
            value = m_queue.front();
            m_queue.pop();  
            rtn = true;
        }
        pthread_mutex_unlock( &m_mutex );
        return rtn;
    }

不幸的是，偶尔会出现可能是此代码错误的问题。也就是说，有两个线程，有时线程 1 永远不会从 push() 中出来，而在其他时候线程 2 永远不会从 pop() 中出来( block 参数为 true) 尽管队列不为空。

我知道还有其他可用的实现，但如果需要，我想尝试修复此代码。有人看到任何问题吗？

构造函数有适当的初始化:

    Queue()
    {
        pthread_mutex_init( &m_mutex, NULL );
        pthread_cond_init( &m_condition, NULL );
    }

和析构函数，相应的“销毁”调用。

Answer 1

正如 Paul Rubel 所提到的，您需要先初始化互斥体。在这一点上，将互斥锁包装在一个将为您处理初始化和完成的类中可能是个好主意。例如:

class mutex {
private:
    mutex(const mutex &m);
    mutex &operator=(const mutex &m);

    // OR inherit from boost::noncopyable
public:
    mutex() {
        pthread_mutex_init(&mut_, nullptr);
    }

    ~mutex() {
        pthread_mutex_destroy(&mut_);
    }

    pthread_mutex_t get() const { return mut_; }

private:
    pthread_mutex_t mut_;
};

值得注意的是 Boost.Threading包含编写良好的同步类的库。