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

This queue is optimized for the case where exactly one thread produces items and exactly one thread consumes them. It provides very low latency and high throughput by avoiding locks and minimizing cache line contention.

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

Usage:

SPSCQueue<Message> queue(1024);

// Producer thread:
if (queue.tryPush(msg)) { /* success */ }
// or with move:
if (queue.tryPush(std::move(msg))) { /* success */ }

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

Thread safety:

• Exactly one thread may call tryPush/emplace (producer)
• 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.

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 the producer and consumer 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.

Attempts to push a copy of item onto the queue. Returns true if successful, false if the queue is full.

Attempts to push item onto the queue using move semantics. Returns true if successful, false if the queue is full.