C++ Equivalent to Java’s BlockingQueue

by

It isn’t fixed size and it doesn’t support timeouts but here is a simple implementation of a queue I had posted recently using C++ 2011 constructs:

#include <mutex>
#include <condition_variable>
#include <deque>

template <typename T>
class queue
{
private:
    std::mutex              d_mutex;
    std::condition_variable d_condition;
    std::deque<T>           d_queue;
public:
    void push(T const& value) {
        {
            std::unique_lock<std::mutex> lock(this->d_mutex);
            d_queue.push_front(value);
        }
        this->d_condition.notify_one();
    }
    T pop() {
        std::unique_lock<std::mutex> lock(this->d_mutex);
        this->d_condition.wait(lock, [=]{ return !this->d_queue.empty(); });
        T rc(std::move(this->d_queue.back()));
        this->d_queue.pop_back();
        return rc;
    }
};

It should be trivial to extend and use a timed wait for popping. The main reason I haven’t done it is that I’m not happy with the interface choices I have thought of so far.

More Related Contents:

  1. Why is volatile not considered useful in multithreaded C or C++ programming?
  2. Simple example of threading in C++
  3. Concurrency: Atomic and volatile in C++11 memory model
  4. Programmatically find the number of cores on a machine
  5. How can I implement ABA counter with c++11 CAS?
  6. Using stdlib’s rand() from multiple threads
  7. Lock-free Progress Guarantees in a circular buffer queue
  8. What are the correct link options to use std::thread in GCC under linux?
  9. Are C++ Reads and Writes of an int Atomic?
  10. When should I use _mm_sfence _mm_lfence and _mm_mfence
  11. How to efficiently display OpenCV video in Qt?
  12. What’s the difference between “static” and “dynamic” schedule in OpenMP?
  13. How to get the cpu usage per thread on windows (win32)
  14. Multi-threading benchmarking issues
  15. Which std::async implementations use thread pools?
  16. pthreads: thread starvation caused by quick re-locking
  17. Get the status of a std::future
  18. How to name a thread in Linux? [duplicate]
  19. Is it ok to read a shared boolean flag without locking it when another thread may set it (at most once)?
  20. Boost::asio – how to interrupt a blocked tcp server thread?
  21. Why does Windows 10 start extra threads in my program?
  22. Is it smart to replace boost::thread and boost::mutex with c++11 equivalents?
  23. Can I use std::async without waiting for the future limitation?
  24. How are user-level threads scheduled/created, and how are kernel level threads created?
  25. C++ terminate called without an active exception
  26. C++ – std::thread crashes upon execution
  27. Why there are three unexpected worker threads when a Win32 console application starts up? [duplicate]
  28. is winsock2 thread safe?
  29. Is a memory barrier required to read a value that is atomically modified?
  30. C++11 Implementation of Spinlock using header “

Leave a Comment