Another way to check std::queue event? - c++

Question

Well, I'm trying to work on some kind of queue. I have an IO thread that it's dedicated for popping data out of the std::queue but the problem is that I'm using a Sleep() in order to prevent 100% cpu constant checking. And of course other threads which will add items to the std::queue.
How could I make an event so that the thread is dormant and only initiates when the std::queue is NOT empty?
IO Thread
Sleep(100);
while (!myqueue.empty())
{
//process data FIFO
myqueue.pop(); //pop out and continue
}
Much appreciated, thank you! Oh and this is for c++11 or c++03 it doesn't matter - on Windows.

Answer 1

std::queue has absolutely nothing to do with threads. At all. Its .empty() member is not thread-safe (only reentrant)! The same applies to all it's other members. So multiple threads can use different queues whatever they like, but only one thread at a time can do anything at all with each instance.
C++11 or C++03 matters a lot. Because C++11 defines thread synchronization primitives, while C++03 does not and you have to use OS API.
In C++11 you would be interested in std::condition_variable.
In C++03 you would be interested in either Boost.Thread (mostly compatible with C++11) Events or Semaphores.
In either case the std::queue::push() and std::queue::pop() themselves must be protected by a mutual exclusion. The std::condition_variable even forces you to use one (std::mutex), in Windows API you'd use Critical Section.
On Windows, the C++11 classes are only available in Visual Studio 2012 and Windows 8. With older compiler use Boost (the advantage is that it will be portable) or native API.

Answer 2

You need a "condition variable". Whenever a thread puts something on the queue it "notifies" threads waiting on the condition variable. The thread that consumes events from the queue waits on the condition variable. It is asleep until someone notifies it via the condition variable.
Boost has a nice implementation: http://www.boost.org/doc/html/thread/synchronization.html#thread.synchronization.condvar_ref
You are using a lock to make sure access to the queue is thread-safe, aren't you?

Answer 3

my suggestion is to first look into how to use a thread safe queue, then perhaps think about using boost::condition signaling to provide more control.
here is an example of how you could build a thread safe queue:
#pragma once
#include <queue>
template<typename T>
class thread_safe_queue
{
queue<T> m_queue;
pthread_mutex_t m_mutex;
pthread_cond_t m_condv;
public:
thread_safe_queue() {
pthread_mutex_init(&m_mutex, NULL);
pthread_cond_init(&m_condv, NULL);
}
~thread_safe_queue() {
pthread_mutex_destroy(&m_mutex);
pthread_cond_destroy(&m_condv);
}
void push(T& item) {
pthread_mutex_lock(&m_mutex);
T itemcpy = std::move(item);
m_queue.push(std::move(itemcpy));
pthread_cond_signal(&m_condv);
pthread_mutex_unlock(&m_mutex);
}
T pop() {
pthread_mutex_lock(&m_mutex);
while (m_queue.size() == 0) {
pthread_cond_wait(&m_condv, &m_mutex);
}
T& _item = m_queue.front();
T itemcpy = std::move(_item);
m_queue.pop();
pthread_mutex_unlock(&m_mutex);
return itemcpy;
}
int size() {
pthread_mutex_lock(&m_mutex);
int size = m_queue.size();
pthread_mutex_unlock(&m_mutex);
return size;
}
};
this is how you instantiate it :
thread_safe_queue<myclass> myqueue;
if you want to use event signaling then look into using boost::condition - fx. like this:
#include <boost/thread/condition.hpp>
#include <boost/thread/mutex.hpp>
boost::mutex mtxWait;
boost::condition cndSignalQueueHasNewEntry;
bool WaitForQueueSignal(long milliseconds)
{
boost::mutex::scoped_lock mtxWaitLock(mtxWait);
boost::posix_time::time_duration wait_duration = boost::posix_time::milliseconds(milliseconds); // http://www.boost.org/doc/libs/1_34_0/doc/html/date_time/posix_time.html
boost::system_time const timeout=boost::get_system_time()+wait_duration; // http://www.justsoftwaresolutions.co.uk/threading/condition-variable-spurious-wakes.html
return cndSignalQueueHasNewEntry.timed_wait(mtxWait,timeout); // wait until signal notify_one or timeout
}
This is how you can signal
cndSignalQueueHasNewEntry.notify_one();
This is how you can wait for signal
bool bResult = WaitForQueueSignal(10000); // timeout after 10 seconds