Thread safety of std::deque

In C++, std::deque is not thread-safe by default. Multiple threads accessing a deque concurrently can lead to race conditions and undefined behavior, unless the access is properly synchronized.

The C++ standard specifies that concurrent access to a standard library container is only safe under certain conditions:

1. Multiple threads can read from a deque concurrently.
2. Multiple threads can write to different deques concurrently.
3. Multiple threads cannot simultaneously access the same deque if at least one of those accesses is a write.

Here's an example of unsafe concurrent access:

1#include <deque>
2#include <thread>
3
4std::deque<int> d{1, 2, 3, 4, 5};
5
6void pushFront() {
7  d.push_front(0);  
8}
9
10void pushBack() {
11  d.push_back(6);  
12}
13
14int main() {
15  std::thread t1(pushFront);
16  std::thread t2(pushBack);
17
18  t1.join();
19  t2.join();
20
21  // The final state of d is undefined
22}

In this example, two threads are simultaneously modifying the deque, which is not safe.

To safely access a deque from multiple threads, you need to use synchronization primitives like mutexes or locks to ensure that only one thread can access the deque at a time:

1#include <deque>
2#include <mutex>
3#include <thread>
4
5std::deque<int> d{1, 2, 3, 4, 5};
6std::mutex m;
7
8void pushFront() {
9  std::lock_guard<std::mutex> lock(m);  
10  d.push_front(0);
11}
12
13void pushBack() {
14  std::lock_guard<std::mutex> lock(m);  
15  d.push_back(6);
16}
17
18int main() {
19  std::thread t1(pushFront);
20  std::thread t2(pushBack);
21
22  t1.join();
23  t2.join();
24
25  // The final state of d is well-defined
26}

Here, a std::mutex is used with std::lock_guard to ensure that only one thread can access the deque at a time.