单消费者单生产者无锁队列#

1
#pragma once
2
#include <atomic>
3
#include <vector>
4
#include <cstddef>
5
#include <cassert>
6

7
template <typename T>
8
class LockFreeQueueSPSC
9
{
10
public:
11
    explicit LockFreeQueueSPSC(size_t capacity)
12
        : buffer_(capacity + 1), capacity_(capacity + 1),
13
          head_(0), tail_(0) {}
14

15
    // 拷贝/移动入队
16
    bool enqueue(const T &item) { return enqueue_impl(item); }
17
    bool enqueue(T &&item) { return enqueue_impl(std::move(item)); }
18

19
    // 原地构造入队
20
    template <typename... Args>
21
    bool emplace(Args &&...args)
22
    {
23
        size_t tail = tail_.load(std::memory_order_relaxed);
24
        size_t next_tail = (tail + 1) % capacity_;
25
        if (next_tail == head_.load(std::memory_order_acquire))
26
            return false; // 队列满
27

28
        buffer_[tail] = T(std::forward<Args>(args)...);
29
        tail_.store(next_tail, std::memory_order_release);
30
        return true;
31
    }
32

33
    bool dequeue(T &item)
34
    {
35
        size_t head = head_.load(std::memory_order_relaxed);
36
        if (head == tail_.load(std::memory_order_acquire))
37
            return false; // 队列空
38

39
        item = std::move(buffer_[head]);
40
        head_.store((head + 1) % capacity_, std::memory_order_release);
41
        return true;
42
    }
43

44
private:
45
    template <typename U>
46
    bool enqueue_impl(U &&item)
47
    {
48
        size_t tail = tail_.load(std::memory_order_relaxed);
49
        size_t next_tail = (tail + 1) % capacity_;
50
        if (next_tail == head_.load(std::memory_order_acquire))
51
            return false; // 队列满
52

53
        buffer_[tail] = std::forward<U>(item);
54
        tail_.store(next_tail, std::memory_order_release);
55
        return true;
56
    }
57

58
private:
59
    std::vector<T> buffer_;     // 队列缓冲区
60
    const size_t capacity_;     // 队列容量
61
    std::atomic<size_t> head_;  // 队头计数器
62
    std::atomic<size_t> tail_;  // 队尾计数器
63
};