How do I implement a lock-free queue in C++?

How do I implement a lock-free queue in C++?

To implement a lock-free queue in C++, you can use atomic operations and a linked list structure. Would you like a code example?

Yes, please provide a code example.

Here's a simple implementation using atomic pointers:

#include <atomic>
#include <memory>

template<typename T>
class LockFreeQueue {
private:
    struct Node {
        T data;
        Node* next;
        Node(T value) : data(value), next(nullptr) {}
    };
    std::atomic<Node*> head;
    std::atomic<Node*> tail;

public:
    LockFreeQueue() {
        Node* dummy = new Node(T());
        head.store(dummy);
        tail.store(dummy);
    }

    void enqueue(T value) {
        Node* newNode = new Node(value);
        Node* oldTail;
        while (true) {
            oldTail = tail.load();
            Node* next = oldTail->next;
            if (next == nullptr) {
                if (oldTail->next.compare_exchange_strong(next, newNode)) {
                    tail.compare_exchange_strong(oldTail, newNode);
                    return;
                }
            } else {
                tail.compare_exchange_strong(oldTail, next);
            }
        }
    }

    std::shared_ptr<T> dequeue() {
        Node* oldHead;
        while (true) {
            oldHead = head.load();
            Node* oldTail = tail.load();
            Node* next = oldHead->next;
            if (oldHead == oldTail) {
                if (next == nullptr) return nullptr; // Queue is empty
                tail.compare_exchange_strong(oldTail, next);
            } else {
                if (head.compare_exchange_strong(oldHead, next)) {
                    return std::make_shared<T>(next->data);
                }
            }
        }
    }
};

This code defines a lock-free queue using atomic operations. Let me know if you have questions!

What are the advantages of using a lock-free queue?

Lock-free queues reduce contention and improve performance in multi-threaded environments. They avoid deadlocks and can lead to better throughput.