Thread Safe Queue in C++

In this article, we will discuss the thread safe queue in C++ with its example.

What is Thread Safe Queue?

A data structure called a thread-safe queue is made to ensure thread safety in concurrent environments. This data structure enables simultaneous enqueuing and dequeuing of elements by several threads using the same queue. The internal organization of the queue ensures that the threads do not conflict with one another, hence there is no need for synchronization. As a result, it offers a quick and safe method for numerous threads to access shared resources.

In multi-threaded code, the C++ thread safe queue enables several threads to use the queue.
Although there isn't a built-in C++ method or class for the thread safe queue, it can be developed with the aid of built-in STL libraries. The movement of data from one thread to another is a challenge that arises when we use multi-threaded code in our program.

Assume that a serial algorithm is divided into separate units for parallel operation. Every task or chunk operates on a different thread, and when a task is finished, it adds the data to the input or output queue so that it can move on to the next one.

The input or output queue needs to be designed in a way that allows data to be added securely by one thread and deleted safely by another without destroying the data structure. It requires the writing of data to the queue to function properly.

Why Thread-Safe Queues Are Necessary?

A simple data structure that adheres to the First-In-First-Out (FIFO) concept is a queue. In concurrent applications, it is often used to manage tasks, messages, and data. Multiple threads may concurrently enqueue (push) and dequeue (pop) elements from a queue in a multi-threaded system. Inadequate synchronization may result in racial circumstances, unpredictable behavior, and corrupted data.

Thread-safe queues are necessary in situations such as these:

Scheduling tasks:
- Thread-safe queues are essential for concurrent job scheduling and execution in multi-threaded applications and parallel processing.
- Tasks can be safely dequeued and processed by other threads after they have been queued by several threads for execution.
Problem of Producer-Consumer:
- One or more threads generate data while others consume it in the producer-consumer issue.
- When transferring data between producers and consumers, a thread-safe queue serves as a mediator to maintain appropriate synchronization and data integrity.
Managing Events:
- Event-driven programs to organize and handle incoming events and messages frequently use thread-safe queues.
- Incoming requests can be enqueued by threads handling events, and worker threads can dequeue and process them simultaneously.

Implementation:

In C++, a mutex plus a normal queue can be used to create a thread-safe queue. A synchronization object called a mutex is employed to safeguard access to a shared resource, like a thread-safe queue. Before pushing or popping elements from the queue, the mutex should be locked, and it should be unlocked once the action is finished. A condition variable is used to wait for changes to the queue, and a mutex is used to secure access to the queue.

Whenever a thread tries to access the queue, the mutex is first utilized to lock it. By doing this, it is ensured that only one thread at a time can access the queue. The thread can release the mutex once it has completed accessing the queue.
After that, a condition variable is utilized to watch for queue modifications. A thread notifies the condition variable that the queue has changed when it adds an item to it. It enables the waking up and continuation of threads that are waiting for queue modifications.
Lastly, a thread must first determine whether the queue is empty before attempting to remove an item from it. If so, it can wait for the addition of an item to the queue by using the condition variable. By doing this, it is ensured that the thread won't try to take an item out of an empty queue.

Example:

Let's take a program to implement Thread Safe Queue in C++:

#include <iostream>
#include <queue>
#include <mutex>
#include <condition_variable>
template <typename T>
class TSQueue {
private:
    std::queue<T> m_queue;
    std::mutex m_mutex;
    std::condition_variable m_cond;
public:
    void push(T item) {
        std::unique_lock<std::mutex> lock(m_mutex);
        m_queue.push(item);
        m_cond.notify_one();
    }
    T pop() {
        std::unique_lock<std::mutex> lock(m_mutex);
        m_cond.wait(lock, [this]() { return !m_queue.empty(); });
        T item = m_queue.front();
        m_queue.pop();
        return item;
    }
};
int main() {
    TSQueue<int> q;

    q.push(1);
    q.push(2);
    q.push(3);
    std::cout << q.pop() << std::endl;
    std::cout << q.pop() << std::endl;
    std::cout << q.pop() << std::endl;
    return 0;
}

Output:

A key component of C++ concurrent programming is thread-safe queues. They ensure data integrity, stop data races, and facilitate smooth coordination across several threads. The particular performance, complexity, and safety requirements of your application will determine which implementation is mutex-based or lock-free is best.

Next TopicStock span problem in C++

← prev next →