mysql::concurrency::Locking_queue< ET > Class Template Reference

Synchronized unbounded FIFO queue for thread-safe producer-consumer operations, using a single mutex and condition variable. More...

#include <locking_queue.h>

Public Types
using	ElemType = ET
using	Memory_resource = mysql::allocators::Memory_resource

Public Member Functions
	Locking_queue (Memory_resource memory_resource={})
	Constructs the queue. More...
	Locking_queue (const Locking_queue< ElemType > &)=delete
	Locking_queue (Locking_queue< ElemType > &&)=delete
Locking_queue &	operator= (const Locking_queue< ElemType > &src)=delete
Locking_queue &	operator= (Locking_queue< ElemType > &&src)=delete
	~Locking_queue ()=default
bool	enqueue (ElemType &&elem)
	Enqueues an element into the queue (called by producers). More...
bool	empty () const
	Checks if the queue is empty. More...
template<typename P >
std::pair< ElemType, bool >	dequeue (P &&pred)
	Consumes (dequeues) an element from the front of the queue. More...
void	notify_all ()
	Wakes all waiting consumers (e.g., during shutdown to check pred and exit). More...

Private Attributes
std::queue< ElemType >	m_queue
	Underlying unbounded FIFO queue. More...
concurrency::Mutex	m_mutex_access_queue
	Mutex protecting all queue operations. More...
concurrency::Condition_variable	m_cv_empty_queue
	Condition variable for waiting on non-empty queue. More...
Memory_resource	m_memory_resource
	Reserved for future custom allocation; currently unused. More...

Detailed Description

template<typename ET>
class mysql::concurrency::Locking_queue< ET >

Synchronized unbounded FIFO queue for thread-safe producer-consumer operations, using a single mutex and condition variable.

This queue is unbounded (enqueue always succeeds). For performance, it does not enforce safe destruction during concurrent access. Ensure the queue outlives all producers and consumers to avoid undefined behavior.

Member Typedef Documentation

ElemType

template<typename ET >

using mysql::concurrency::Locking_queue< ET >::ElemType = ET

Memory_resource

template<typename ET >

using mysql::concurrency::Locking_queue< ET >::Memory_resource = mysql::allocators::Memory_resource

Constructor & Destructor Documentation

Locking_queue() [1/3]

template<typename ET >

mysql::concurrency::Locking_queue< ET >::Locking_queue ( Memory_resource  memory_resource = {} )

inline

Constructs the queue.

The memory_resource is reserved for future use (e.g., custom allocation for elements) and currently unused.

Locking_queue() [2/3]

template<typename ET >

mysql::concurrency::Locking_queue< ET >::Locking_queue ( const Locking_queue< ElemType > &  )

delete

Locking_queue() [3/3]

template<typename ET >

mysql::concurrency::Locking_queue< ET >::Locking_queue ( Locking_queue< ElemType > &&  )

delete

~Locking_queue()

template<typename ET >

mysql::concurrency::Locking_queue< ET >::~Locking_queue ( )

default

Member Function Documentation

dequeue()

template<typename ET >

template<typename P >

std::pair< ElemType, bool > mysql::concurrency::Locking_queue< ET >::dequeue ( P &&  pred )

inline

Consumes (dequeues) an element from the front of the queue.

Blocks until an element is available or the stop predicate triggers.

Parameters

pred	Stop predicate (callable); if pred() returns true after waking, stops waiting and returns without consuming.

Returns

std::pair<ElemType, bool>: {consumed element, true} if an element was dequeued, or {default-constructed ElemType, false} if stopped by pred() without consuming.

empty()

template<typename ET >

bool mysql::concurrency::Locking_queue< ET >::empty ( ) const

inline

Checks if the queue is empty.

Acquires the mutex for thread-safe access. Due to concurrent enqueues/consumes, the result is a snapshot and may change immediately after the call.

Returns

true if no elements are present at the time of the check.

enqueue()

template<typename ET >

bool mysql::concurrency::Locking_queue< ET >::enqueue ( ElemType &&  elem )

inline

Enqueues an element into the queue (called by producers).

Parameters

elem	Element to enqueue (moved).

Returns

Always true, as the queue is unbounded and enqueue always succeeds.

Acquires the mutex, pushes the element to the back, notifies one waiting consumer, then releases the mutex.

notify_all()

template<typename ET >

void mysql::concurrency::Locking_queue< ET >::notify_all ( )

inline

Wakes all waiting consumers (e.g., during shutdown to check pred and exit).

Notifies all on the condition variable, unblocking blocked consumes.

operator=() [1/2]

template<typename ET >

Locking_queue & mysql::concurrency::Locking_queue< ET >::operator= ( const Locking_queue< ElemType > &  src )

delete

operator=() [2/2]

template<typename ET >

Locking_queue & mysql::concurrency::Locking_queue< ET >::operator= ( Locking_queue< ElemType > &&  src )

delete

Member Data Documentation

m_cv_empty_queue

template<typename ET >

concurrency::Condition_variable mysql::concurrency::Locking_queue< ET >::m_cv_empty_queue

private

Condition variable for waiting on non-empty queue.

m_memory_resource

template<typename ET >

Memory_resource mysql::concurrency::Locking_queue< ET >::m_memory_resource

private

Reserved for future custom allocation; currently unused.

m_mutex_access_queue

template<typename ET >

concurrency::Mutex mysql::concurrency::Locking_queue< ET >::m_mutex_access_queue

mutableprivate

Mutex protecting all queue operations.

m_queue

template<typename ET >

std::queue<ElemType> mysql::concurrency::Locking_queue< ET >::m_queue

private

Underlying unbounded FIFO queue.

---

The documentation for this class was generated from the following file:

• libs/mysql/concurrency/locking_queue.h