Implement a Stoppable Producer–Consumer System in C++ (Medium)

Design and implement a C++ system with three classes: Storage, Factory, and Consumer to manage a producer-consumer pattern with rate control and graceful shutdown.

Constraints & Assumptions

• Storage is a fixed-capacity FIFO (First-In, First-Out) queue for int values.
• store(item): Attempts to insert an item. It is non-blocking and returns true on success. If the storage is full, it does nothing and returns false.
• retrieve(result): Attempts to remove the oldest item. It is non-blocking and returns true on success, placing the item in result. If the storage is empty, it does nothing and returns false.
• The system operates with one factory and one consumer running concurrently.
• A positive itemsPerSec parameter controls the rate at which each worker attempts its operations.
• The caller is responsible for initiating and managing the shutdown process, not a hardcoded timer within the worker threads.

Core Implementation Tasks:

1. Thread-Safe Bounded Storage: Implement the Storage class with thread-safe store and retrieve methods. Explain critical sections, atomicity, and why separate checks for empty or full before mutation are unsafe. Ensure exception-safe locking and FIFO semantics.
2. Rate-Controlled Workers and Shutdown: Implement Factory and Consumer classes. The factory produces sequential integers (0, 1, 2, ...). If store fails due to a full queue, the item is dropped, and the next attempt uses the next integer. The consumer attempts one retrieval per rate-controlled period. Implement a mechanism for the caller to request shutdown and ensure worker threads are stopped and joined promptly.
3. Memory Ordering and Lock-Free Extension: Discuss the implications of memory ordering for the shutdown flag (why a plain bool is insufficient). Explain when relaxed atomic ordering is acceptable and when acquire/release semantics are necessary. Explore how a fixed-size, single-producer/single-consumer (SPSC) ring buffer could replace the mutex-based queue for the Storage component. Analyze the data-race and happens-before implications, safe publication of writes, and safe reuse of slots. Discuss why this SPSC design doesn't directly generalize to multiple producers or consumers.