1
#pragma once
2

3
#include <atomic>
4
#include <vector>
5
#include <cstddef>
6
#include <stdexcept>
7

8
template <typename T>
9
class LockFree_ObjectPool
10
{
11
private:
12
    struct Node
13
    {
14
        T *object;  // 指向实际对象
15
        Node *next; // 指向下一个空闲节点
16
    };
17

18
    std::atomic<Node *> head_; // 空闲链表的头
19
    std::vector<T> storage_;   // 存储实际对象的数组
20
    std::vector<Node> nodes_;  // 存储空闲节点的数组
21

22
public:
23
    explicit LockFree_ObjectPool(size_t capacity)
24
        : storage_(capacity), nodes_(capacity)
25
    {
26
        if (capacity == 0)
27
        {
28
            throw std::invalid_argument("capacity must be greater than 0");
29
        }
30

31
        for (size_t i = 0; i < capacity; ++i)
32
        {
33
            nodes_[i].object = &storage_[i];
34
            nodes_[i].next = (i + 1 < capacity) ? &nodes_[i + 1] : nullptr;
35
        }
36
        head_.store(&nodes_[0], std::memory_order_release);
37
    }
38

39
    LockFree_ObjectPool(const LockFree_ObjectPool &) = delete;            // 禁止拷贝构造
40
    LockFree_ObjectPool &operator=(const LockFree_ObjectPool &) = delete; // 禁止赋值操作
41

42
    T *acquire()
43
    {
44
        Node *node = pop();
45
        return node ? node->object : nullptr;
46
    }
47

48
    void release(T *object)
49
    {
50
        if (!object)
51
            return;
52
        size_t index = static_cast<size_t>(object - &storage_[0]);
53
        push(&nodes_[index]);
54
    }
55

56
private:
57
    void push(Node *node)
58
    {
59
        Node *oldHead = nullptr;
60
        do
61
        {
62
            oldHead = head_.load(std::memory_order_acquire);
63
            node->next = oldHead;
64
        } while (!head_.compare_exchange_weak(oldHead, node, std::memory_order_release, std::memory_order_relaxed));
65
    }
66

67
    Node *pop()
68
    {
69
        Node *oldHead = nullptr;
70

71
        do
72
        {
73
            oldHead = head_.load(std::memory_order_acquire);
74
            if (!oldHead)
75
                return nullptr;
76
        } while (!head_.compare_exchange_weak(oldHead, oldHead->next, std::memory_order_release, std::memory_order_relaxed));
77

78
        return oldHead;
79
    }
80
};