C ++ Equivalente a BlockingQueue de Java

Estoy en el proceso de transferir algún código de Java a C ++, y una sección en particular utiliza un BlockingQueue para pasar mensajes de muchos productores a un solo consumidor.

Si no está familiarizado con lo que es una Java BlockingQueue, es solo una cola que tiene una capacidad difícil, que expone los métodos de seguridad de subprocesos a put () y take () desde la cola. put () bloques si la cola está llena, y take () bloques si la cola está vacía. Además, se suministran versiones sensibles al tiempo de espera de estos métodos.

Los tiempos de espera son relevantes para mi caso de uso, por lo que una recomendación que los proporcione es ideal. Si no, puedo codificar yo mismo.

Busqué en Google y navegué rápidamente por las bibliotecas de Boost y no encuentro nada como esto. Tal vez estoy ciego aquí … pero ¿alguien sabe de una buena recomendación?

¡Gracias!

No es de tamaño fijo y no admite tiempos de espera, pero aquí hay una implementación simple de una cola que publiqué recientemente usando constructos de C ++ 2011:

#include  #include  #include  template  class queue { private: std::mutex d_mutex; std::condition_variable d_condition; std::deque d_queue; public: void push(T const& value) { { std::unique_lock lock(this->d_mutex); d_queue.push_front(value); } this->d_condition.notify_one(); } T pop() { std::unique_lock 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; } }; 

Debe ser trivial extender y usar una espera temporizada para estallar. La razón principal por la que no lo hice es porque no estoy contento con las opciones de interfaz en las que he pensado hasta ahora.

Aquí hay un ejemplo de una cola de locking con la función de solicitud de cierre :

 template  class BlockingQueue { std::condition_variable _cvCanPop; std::mutex _sync; std::queue _qu; bool _bShutdown = false; public: void Push(const T& item) { { std::unique_lock lock(_sync); _qu.push(item); } _cvCanPop.notify_one(); } void RequestShutdown() { { std::unique_lock lock(_sync); _bShutdown = true; } _cvCanPop.notify_all(); } bool Pop(T &item) { std::unique_lock lock(_sync); for (;;) { if (_qu.empty()) { if (_bShutdown) { return false; } } else { break; } _cvCanPop.wait(lock); } item = std::move(_qu.front()); _qu.pop(); return true; } };