Edit
To make this question more complete, here is the code for the thread safe queue that I'm using. Note this is shamelessly copied from C++ Concurrency in action (minus the emplace method - which I now use instead of push).
#include <queue>
#include <memory>
#include <mutex>
#include <condition_variable>
template<typename T>
class threadsafe_queue
{
public:
threadsafe_queue() {}
threadsafe_queue(const threadsafe_queue& other)
{
std::lock_guard<std::mutex> lock(other.mut);
data_queue = other.data_queue;
}
void push(T new_value)
{
std::lock_guard<std::mutex> lock(mut);
data_queue.push(new_value);
data_cond.notify_one();
}
template<typename... Args>
void emplace(Args... args)
{
std::lock_guard<std::mutex> lock(mut);
data_queue.emplace(args...);
data_cond.notify_one();
}
void wait_and_pop(T& value)
{
std::unique_lock<std::mutex> lock(mut);
data_cond.wait(lock, [this]{return !data_queue.empty();});
value = data_queue.front();
data_queue.pop();
}
std::shared_ptr<T> wait_and_pop()
{
std::unique_lock<std::mutex> lock(mut);
data_cond.wait(lock, [this]{return !data_queue.empty();});
std::shared_ptr<T> result(std::make_shared<T>(data_queue.front()));
return result;
}
bool try_pop(T& value)
{
std::lock_guard<std::mutex> lock(mut);
if (data_queue.empty()) { return false; }
value = data_queue.front();
data_queue.pop();
return true;
}
std::shared_ptr<T> try_pop()
{
std::lock_guard<std::mutex> lock(mut);
if (data_queue.empty()) {
return std::shared_ptr<T>();
}
std::shared_ptr<T> result(std::make_shared<T>(data_queue.front()));
data_queue.pop();
return result;
}
bool empty() const
{
std::lock_guard<std::mutex> lock(mut);
return data_queue.empty();
}
private:
mutable std::mutex mut;
std::queue<T> data_queue;
std::condition_variable data_cond;
};
