C++中无锁队列与有锁队列的实现

#include <queue>
#include <mutex>
#include <condition_variable>

template <typename T>
class LockedQueue {
private:
    std::queue<T> queue_;
    mutable std::mutex mutex_;
    std::condition_variable cond_;

public:
    // 插入元素（线程安全）
    void push(T value) {
        {
            std::lock_guard<std::mutex> lock(mutex_);
            queue_.push(std::move(value));
        }  // 自动解锁作用域
        cond_.notify_one();  // 通知等待线程
    }

    // 非阻塞弹出（立即返回）
    bool try_pop(T& value) {
        std::lock_guard<std::mutex> lock(mutex_);
        if (queue_.empty()) return false;
        value = std::move(queue_.front());
        queue_.pop();
        return true;
    }

    // 阻塞式弹出（等待元素）
    void wait_and_pop(T& value) {
        std::unique_lock<std::mutex> lock(mutex_);
        // 条件等待：防止虚假唤醒
        cond_.wait(lock, [this] { return !queue_.empty(); });
        value = std::move(queue_.front());
        queue_.pop();
    }

    // 可选：队列大小（非精确值）
    size_t size() const {
        std::lock_guard<std::mutex> lock(mutex_);
        return queue_.size();
    }
};

#include <atomic>
#include <memory>
#include <vector>

template <typename T>
class LockFreeSPSCQueue {
private:
    struct Node {
        std::atomic<Node*> next;
        T data;
        Node() : next(nullptr) {}  // Dummy node
        Node(T val) : data(std::move(val)), next(nullptr) {}
    };

    // 缓存行对齐（64字节）防止伪共享
    alignas(64) std::atomic<Node*> head_;
    alignas(64) std::atomic<Node*> tail_;

    // 预分配节点池（减少内存分配开销）
    std::vector<std::unique_ptr<Node>> node_pool_;

    Node* alloc_node(T value = T{}) {
        node_pool_.push_back(std::make_unique<Node>(std::move(value)));
        return node_pool_.back().get();
    }

public:
    LockFreeSPSCQueue() {
        Node* dummy = alloc_node();  // 创建虚拟节点
        head_.store(dummy, std::memory_order_relaxed);
        tail_.store(dummy, std::memory_order_relaxed);
    }

    ~LockFreeSPSCQueue() {
        // 自动清理通过 unique_ptr 管理
    }

    // 生产者操作
    void push(T value) {
        Node* new_node = alloc_node(std::move(value));
        Node* old_tail = tail_.exchange(new_node, std::memory_order_acq_rel);
        
        // 关键：先设置 tail 再连接 next
        old_tail->next.store(new_node, std::memory_order_release);
    }

    // 消费者操作
    bool pop(T& value) {
        Node* old_head = head_.load(std::memory_order_relaxed);
        Node* next_ptr = old_head->next.load(std::memory_order_acquire);

        if (!next_ptr) return false;  // 空队列
        
        // 移动数据并更新头节点
        value = std::move(next_ptr->data);
        head_.store(next_ptr, std::memory_order_release);
        
        // 回收旧头节点（实际由 node_pool_ 统一管理）
        old_head->next.store(nullptr, std::memory_order_relaxed);
        return true;
    }
};

// 使用带标记指针的原子操作
struct TaggedPtr {
    Node* ptr;
    uintptr_t tag;  // 操作计数器
};

std::atomic<TaggedPtr> head_;

bool pop(T& value) {
    TaggedPtr old_head = head_.load();
    while (true) {
        Node* next = old_head.ptr->next.load();
        if (!next) return false;
        TaggedPtr new_head{next, old_head.tag + 1};
        if (head_.compare_exchange_weak(old_head, new_head)) {
            value = next->data;
            return true;
        }
    }
}