c++ 无锁队列的简单实现

无锁队列的基本介绍

一个关于无锁队列的多线程读写代码示例。在这里，我提供一个简单的示例来说明这个问题。
在使用无锁队列时，需要注意以下几点：
使用原子操作来实现对队列的读写操作，以避免多线程同时访问同一数据导致的竞争条件问题。
当队列为空或已满时，需要使用特殊的标记来表示队列的状态。
使用链表来实现的无锁队列
下面是一个使用无锁队列的多线程读写代码示例：

#include <atomic>
#include <thread>
#include <iostream>
template <typename T>
class LockFreeQueue
{
public:
    LockFreeQueue() : m_head(new Node), m_tail(m_head.load()) {}
    ~LockFreeQueue()
    {
        while (Node* const old_head = m_head)
        {
            m_head = old_head->next;
            delete old_head;
        }
    }
    void enqueue(T value)
    {
        Node* const new_node = new Node(value);
        Node* old_tail = m_tail.exchange(new_node);
        old_tail->next = new_node;
    }
    bool dequeue(T& value)
    {
        Node* old_head = m_head;
        Node* new_head;
        do
        {
            if (old_head->next == nullptr)
            {
                return false;
            }
            new_head = old_head->next;
        } while (!m_head.compare_exchange_weak(old_head, new_head));
        value = new_head->value;
        delete old_head;
        return true;
    }
private:
    struct Node
    {
        T value;
        Node* next;
        Node() : next(nullptr) {}
        Node(T value) : value(value), next(nullptr) {}
    };
    std::atomic<Node*> m_head;
    std::atomic<Node*> m_tail;
};
int main()
{
    LockFreeQueue<int> queue;
    std::thread t1([&queue]()
    {
        for (int i = 0; i < 10; ++i)
        {
            queue.enqueue(i);
        }
    });
    std::thread t2([&queue]()
    {
        int value = 0;
        while (value < 9)
        {
            if (queue.dequeue(value))
            {
                std::cout << "Dequeued value: " << value << std::endl;
            }
        }
    });
    t1.join();
    t2.join();
    return 0;
}

这段代码实现了一个无锁队列，其中enqueue()函数用于向队列中添加元素，dequeue()函数用于从队列中取出元素。在这个示例中，我们使用了C++11中的std::atomic来实现原子操作，以确保多线程访问时的线程安全。同时，我们使用了compare_exchange_weak()函数来确保多线程环境下的原子操作。

以环形队列实现无锁队列

#include <atomic>
template <typename T>
class LockFreeQueue {
public:
    LockFreeQueue(size_t capacity = 1024) : m_capacity(capacity) {
        m_data = new T[m_capacity];
        m_head.store(0, std::memory_order_relaxed);
        m_tail.store(0, std::memory_order_relaxed);
    }
    ~LockFreeQueue() {
        delete[] m_data;
        m_data = nullptr;
    }
    bool push(const T& item) {
        size_t tail = m_tail.load(std::memory_order_relaxed);
        size_t head = m_head.load(std::memory_order_acquire);
        size_t count = tail - head;
        if (count >= m_capacity - 1) {
            return false;
        }
        m_data[tail % m_capacity] = item;
        m_tail.store(tail + 1, std::memory_order_release);
        return true;
    }
    bool pop(T& item) {
        size_t head = m_head.load(std::memory_order_relaxed);
        size_t tail = m_tail.load(std::memory_order_acquire);
        size_t count = tail - head;
        if (count == 0) {
            return false;
        }
        item = m_data[head % m_capacity];
        m_head.store(head + 1, std::memory_order_release);
        return true;
    }
private:
    T* m_data;
    size_t m_capacity;
    std::atomic<size_t> m_head;
    std::atomic<size_t> m_tail;
};

这个队列是一个环形队列，使用了两个原子变量 m_head 和 m_tail 分别表示队列头和队列尾，通过利用原子操作保证线程安全，实现了无锁的操作。同时，使用了 memory_order 来保证数据的可见性和原子性。