C++11 thread-safe queue

by

It is best to make the condition (monitored by your condition variable) the inverse condition of a while-loop:
while(!some_condition). Inside this loop, you go to sleep if your condition fails, triggering the body of the loop.

This way, if your thread is awoken–possibly spuriously–your loop will still check the condition before proceeding. Think of the condition as the state of interest, and think of the condition variable as more of a signal from the system that this state might be ready. The loop will do the heavy lifting of actually confirming that it’s true, and going to sleep if it’s not.

I just wrote a template for an async queue, hope this helps. Here, q.empty() is the inverse condition of what we want: for the queue to have something in it. So it serves as the check for the while loop.

#ifndef SAFE_QUEUE
#define SAFE_QUEUE

#include <queue>
#include <mutex>
#include <condition_variable>

// A threadsafe-queue.
template <class T>
class SafeQueue
{
public:
  SafeQueue(void)
    : q()
    , m()
    , c()
  {}

  ~SafeQueue(void)
  {}

  // Add an element to the queue.
  void enqueue(T t)
  {
    std::lock_guard<std::mutex> lock(m);
    q.push(t);
    c.notify_one();
  }

  // Get the "front"-element.
  // If the queue is empty, wait till a element is avaiable.
  T dequeue(void)
  {
    std::unique_lock<std::mutex> lock(m);
    while(q.empty())
    {
      // release lock as long as the wait and reaquire it afterwards.
      c.wait(lock);
    }
    T val = q.front();
    q.pop();
    return val;
  }

private:
  std::queue<T> q;
  mutable std::mutex m;
  std::condition_variable c;
};
#endif

More Related Contents:

  1. C++11 introduced a standardized memory model. What does it mean? And how is it going to affect C++ programming?
  2. How do I terminate a thread in C++11?
  3. Concurrency: Atomic and volatile in C++11 memory model
  4. Passing object by reference to std::thread in C++11
  5. Why don’t compilers merge redundant std::atomic writes?
  6. What are the correct link options to use std::thread in GCC under linux?
  7. Why is the destructor of a future returned from `std::async` blocking?
  8. std::thread pass by reference calls copy constructor
  9. How to implement multithread safe singleton in C++11 without using
  10. Difference between pointer and reference as thread parameter
  11. How to use std::async on a member function?
  12. Which std::async implementations use thread pools?
  13. C++0x thread interruption
  14. How can I use something like std::vector?
  15. What is the difference between packaged_task and async
  16. Get the status of a std::future
  17. Delayed start of a thread in C++ 11
  18. Is it smart to replace boost::thread and boost::mutex with c++11 equivalents?
  19. C++11 STL containers and thread safety
  20. Can I use std::async without waiting for the future limitation?
  21. C++ terminate called without an active exception
  22. What is different between join() and detach() for multi threading in C++?
  23. std::thread error (thread not member of std)
  24. C++11 std::threads vs posix threads
  25. Understanding std::atomic::compare_exchange_weak() in C++11
  26. Double-Checked Lock Singleton in C++11
  27. C++11 Implementation of Spinlock using header “
  28. std::thread calling method of class [duplicate]
  29. Write concurrently vector
  30. About thread-safety of weak_ptr

Leave a Comment