Thread Safety with std::queue

By default, std::queue is not thread-safe. Multiple threads accessing the same std::queue object concurrently can lead to race conditions and undefined behavior. If you need to use queues in a multi-threaded environment, you must implement your own synchronization mechanisms to ensure thread safety.

Here are a few approaches to using queues safely in a multi-threaded environment:

Mutex-based synchronization

You can use a mutex to synchronize access to the queue. Before performing any operation on the queue, a thread must acquire a lock on the mutex. Once the operation is complete, the thread releases the lock, allowing other threads to access the queue.

1#include <iostream>
2#include <mutex>
3#include <queue>
4#include <thread>
5
6std::queue<int> myQueue;
7std::mutex queueMutex;
8
9void pushToQueue(int value) {
10  std::unique_lock<std::mutex> lock(queueMutex);
11  myQueue.push(value);
12}
13
14int popFromQueue() {
15  std::unique_lock<std::mutex> lock(queueMutex);
16  if (!myQueue.empty()) {
17    int value = myQueue.front();
18    myQueue.pop();
19    return value;
20  }
21  // Return a default value if the queue is empty
22  return -1;
23}
24
25// Thread function
26void threadFunction() {
27  pushToQueue(10);
28  int value = popFromQueue();
29  std::cout << std::format(
30    "Popped value: {} \n", value);
31}
32
33int main() {
34  std::thread t1(threadFunction);
35  std::thread t2(threadFunction);
36
37  t1.join();
38  t2.join();
39}

1Popped value: 10
2Popped value: 10

In this example, we use a std::mutex named queueMutex to synchronize access to the myQueue object. The pushToQueue and popFromQueue functions acquire a lock on the mutex before performing any operations on the queue. This ensures that only one thread can access the queue at a time, preventing race conditions.

Lock-free queues

If you require high-performance and low-latency access to queues in a multi-threaded environment, you can consider using lock-free queue implementations. Lock-free queues use atomic operations and clever algorithms to allow concurrent access without explicit locking.

However, implementing lock-free queues correctly can be challenging and requires careful consideration of memory ordering and synchronization primitives.

There are various lock-free queue implementations available, such as boost::lockfree::queue from the Boost library or moodycamel::ConcurrentQueue from the moodycamel library. These implementations provide thread-safe queue operations without the need for explicit locking.

1#include <boost/lockfree/queue.hpp>
2#include <iostream>
3#include <thread>
4
5// Create a lock-free queue with capacity of 100
6boost::lockfree::queue<int> myQueue(100);
7
8void pushToQueue(int value) {
9  myQueue.push(value);
10}
11
12int popFromQueue() {
13  int value;
14  if (myQueue.pop(value)) {
15    return value;
16  }
17  // Return a default value if the queue is empty
18  return -1;
19}
20
21// Thread function
22void threadFunction() {
23  pushToQueue(10);
24  int value = popFromQueue();
25  std::cout << std::format(
26    "Popped value: {} \n", value);
27}
28
29int main() {
30  std::thread t1(threadFunction);
31  std::thread t2(threadFunction);
32
33  t1.join();
34  t2.join();
35}

1Popped value: 10
2Popped value: 10

In this example, we use the boost::lockfree::queue from the Boost library to create a lock-free queue. The pushToQueue and popFromQueue functions can be called concurrently by multiple threads without the need for explicit locking.

When using queues in a multi-threaded environment, it's crucial to carefully design your synchronization mechanism to ensure thread safety and avoid race conditions. The choice between using explicit locking or lock-free queues depends on your specific requirements, performance needs, and the complexity of your system.