Thread safety with std::stack

No, std::stack is not thread-safe by itself. If you access a std::stack concurrently from multiple threads and at least one of those accesses is a write (i.e., modifying the stack), you need to manually synchronize access to the stack to avoid data races and undefined behavior.

Here's an example that demonstrates the problem:

1#include <stack>
2#include <thread>
3
4std::stack<int> globalStack;
5
6void pushToStack(int value) {
7  globalStack.push(value); }
8
9void popFromStack() {
10  if (!globalStack.empty()) {
11    globalStack.pop();
12  }
13}
14
15int main() {
16  std::thread t1(pushToStack, 1);
17  std::thread t2(popFromStack);
18
19  t1.join();
20  t2.join();
21}

In this code, t1 is trying to push to the stack while t2 is trying to pop from it, concurrently. This is a classic data race. The behavior is undefined and can lead to hard-to-debug problems.

To make this code safe, you need to use a synchronization primitive like a mutex:

1#include <mutex>
2#include <stack>
3#include <thread>
4
5std::stack<int> globalStack;
6std::mutex stackMutex;
7
8void pushToStack(int value) {
9  stackMutex.lock();
10  globalStack.push(value);
11  stackMutex.unlock();
12}
13
14void popFromStack() {
15  stackMutex.lock();
16  if (!globalStack.empty()) {
17    globalStack.pop();
18  }
19  stackMutex.unlock();
20}
21
22int main() {
23  std::thread t1(pushToStack, 1);
24  std::thread t2(popFromStack);
25
26  t1.join();
27  t2.join();
28}

Now, only one thread can access the stack at a time, preventing data races.

If you need a thread-safe stack-like data structure, you can consider using std::queue with a std::mutex and a std::condition_variable for synchronization, or use a lock-free stack implementation.

Remember, whenever you have shared mutable state accessed by multiple threads, you need to synchronize access to that state. The C++ standard library containers, including std::stack, are not thread-safe by themselves.