我最近做了类似的事情,尽管我使用STL队列。看看您是否可以从我的实现中挑选出来。AS
wilx
说,你需要在这种情况下等待。我的实现对队列中的元素有最大限制,我使用它来等待互斥/保护被释放。
我最初在Windows上做这项工作时考虑到了使用互斥体或关键部分的能力,因此可以删除和使用模板参数。
boost::mutex
如果它为您简化了它,就可以直接使用。
#include <queue>
#include "Message.h"
#include <boost/thread/locks.hpp>
#include <boost/thread/condition.hpp>
template <typename T> class Queue : private boost::noncopyable
{
public:
// constructor binds the condition object to the Q mutex
Queue(T & mutex, size_t max_size) : m_max_size(max_size), m_mutex(mutex){}
// writes messages to end of Q
void put(const Message & msg)
{
// Lock mutex to ensure exclusive access to Q
boost::unique_lock<T> guard(m_mutex);
// while Q is full, sleep waiting until something is taken off of it
while (m_queue.size() == m_max_size)
{
cond.wait(guard);
}
// ok, room on the queue.
// Add the message to the queue
m_queue.push(msg);
// Indicate so data can be ready from Q
cond.notify_one();
}
// Read message from front of Q. Message is removed from the Q
Message get(void)
{
// Lock mutex to ensure exclusive access to Q
boost::unique_lock<T> guard(m_mutex);
// If Q is empty, sleep waiting for something to be put onto it
while (m_queue.empty())
{
cond.wait(guard);
}
// Q not empty anymore, read the value
Message msg = m_queue.front();
// Remove it from the queue
m_queue.pop();
// Signal so more data can be added to Q
cond.notify_one();
return msg;
}
size_t max_size(void) const
{
return m_max_size;
}
private:
const size_t m_max_size;
T & m_mutex;
std::queue<Message> m_queue;
boost::condition_variable_any cond;
};
这样,您就可以在生产者/消费者之间共享队列。示例用法
boost::mutex mutex;
Queue<boost::mutex> q(mutex, 100);
boost::thread_group threads;
threads.create_thread(Producer<boost::mutex>(q));
threads.create_thread(Consumer<boost::mutex>(q));
threads.join_all();
生产商/消费者定义如下
template <typename T> class Producer
{
public:
// Queue passed in
explicit Producer(Queue<T> &q) : m_queue(q) {}
void operator()()
{
}
}
