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