A lock-free multi-producer single-consumer (MPSC) bounded queue.

This queue is optimized for the case where multiple threads produce items and exactly one thread consumes them.

The queue uses a bounded ring buffer with atomic operations. Producers use compare-and-swap to reserve slots; the consumer reads committed entries in order.

The queue has a fixed capacity specified at construction time. When full, tryPush() returns false. When empty, tryPop() returns false.

Usage:

MPSCQueue<Message> queue(1024);

// Producer threads (any number):
if (queue.tryPush(msg)) { /* success */ }

// Consumer thread (exactly one):
Message msg;
if (queue.tryPop(msg)) { /* got message */ }

Thread safety:

• Multiple threads may call tryPush/emplace concurrently (producers)
• Exactly one thread may call tryPop (consumer)
• size(), empty(), capacity() may be called from any thread

Note: This queue does not provide blocking operations. For blocking behavior, combine with a semaphore or condition variable.

Creates the queue with the given capacity. Capacity must be at least 1 and will be rounded up to the next power of two for efficient indexing.

Destroys the queue.

Returns the capacity of the queue.

Attempts to construct an item in-place at the back of the queue. Returns true if successful, false if the queue is full. Thread-safe for multiple concurrent producers.

Returns true if the queue appears to be empty. This is approximate for the same reason as size().

Returns an approximate count of items in the queue. This is approximate because producers may be modifying the queue concurrently.

Attempts to pop an item from the queue. If successful, moves the item into the provided reference and returns true. Returns false if the queue is empty. Must be called from exactly one thread (the consumer).

Attempts to push a copy of item onto the queue. Returns true if successful, false if the queue is full. Thread-safe for multiple concurrent producers.

Attempts to push item onto the queue using move semantics. Returns true if successful, false if the queue is full. Thread-safe for multiple concurrent producers.