A comprehensive C++17 library featuring five different implementations of thread-safe stacks. This project is designed to demonstrate various synchronization strategies, from simple mutex guarding to advanced fine-grained locking and memory-efficient node management.

• Diverse Implementations: 5 distinct stack architectures tailored for different contention levels.
• Zero-Guesswork Testing: 100% coverage with Google Test (GTest) suite.
• Pro Benchmarking: Built-in performance analyzer measuring throughput in MOps/s.
• Exception Safety: Advanced use of std::shared_ptr to ensure data integrity during concurrent access.

Configuration: 8 threads (4 Producers / 4 Consumers) | CPU: 8C / 16T @ 1.9 GHz

Focus: synchronization overhead and contention.

Focus: memory pressure and lock duration.

1. The std::deque Advantage: The Basic and Waiting Mutex stacks (built on std::stack) significantly outperform the custom Linked-List versions. This is primarily due to std::deque's block-allocation strategy. By allocating memory in chunks rather than per-node, it minimizes calls to the global allocator and maximizes CPU cache locality.
2. The Hidden Cost of Nodes: Contrary to theoretical expectations, the "optimization" of allocating nodes outside the critical section in the Linked List and SharedPtr versions actually hindered performance. The overhead of frequent new/delete operations and the creation of std::shared_ptr control blocks (especially visible in the 285ms result) outweighed the benefits of shorter lock-holding times.
3. Efficiency of Condition Variables: In the Heavy Payload category, the Waiting Mutex Stack [WAIT] (using waitAndPop) achieved the best result (123.54ms). This demonstrates that for larger data, using a std::condition_variable is more efficient than aggressive tryPop polling, as it reduces useless lock contention when the stack is empty.
4. Scaling Observations: While Linked-List structures are often praised for concurrency, your results show that for a 4P/4C load on an 8-core machine, the contention management of a standard mutex wrapper around a contiguous-ish container (deque) is far superior to the overhead of a node-based architecture.

Recommendation: For most general-purpose applications, a Waiting Mutex Stack based on std::deque is the optimal choice. Only move to Linked-List or Lock-Free structures if you are dealing with extremely high contention or real-time requirements where individual latency spikes from std::deque reallocations are unacceptable.

• C++17 Compiler (GCC 9+, Clang 10+, MSVC 2019+)
• CMake 3.10+
• Google Test (will be fetched automatically if using CMake)

# Clone the repository
git clone https://github.com/NotACat1/ThreadSafeStack.git
cd ThreadSafeStack

# Build Benchmark in Release mode (Crucial for performance!)
g++ -O3 -std=c++17 -pthread main.cpp -o benchmark
./ThreadSafeStack

1. Reduce Critical Sections: We aim to keep the code inside std::lock_guard as minimal as possible.
2. Smart Memory Management: Using std::make_shared before locking allows multiple threads to prepare data in parallel.
3. Modern C++: Utilizing RAII, std::optional-like interfaces (via tryPop), and move semantics for maximum efficiency.