如何实现C++中的无锁数据结构？

#include <atomic>
#include <memory>

template<typename T>
class LockFreeQueue {
private:
    struct Node {
        std::shared_ptr<T> data;
        Node* next;
        Node(T const& data_) : data(std::make_shared<T>(data_)), next(nullptr) {}
    };

    std::atomic<Node*> head;
    std::atomic<Node*> tail;

public:
    LockFreeQueue() : head(new Node(T())), tail(head.load()) {}

    ~LockFreeQueue() {
        while (Node* const old_head = head.load()) {
            head.store(old_head->next);
            delete old_head;
        }
    }

    void enqueue(T const& data) {
        Node* new_node = new Node(data);
        Node* old_tail = nullptr;
        Node* old_next = nullptr;

        while (true) {
            old_tail = tail.load();
            old_next = old_tail->next.load();

            if (old_tail == tail.load()) {
                if (old_next == nullptr) {
                    if (old_tail->next.compare_exchange_strong(old_next, new_node)) {
                        break;
                    }
                } else {
                    tail.compare_exchange_strong(old_tail, old_next);
                }
            }
        }

        tail.compare_exchange_strong(old_tail, new_node);
    }

    bool dequeue(T& result) {
        Node* old_head = head.load();
        Node* old_tail = tail.load();
        Node* new_head = old_head->next.load();

        if (old_head == head.load()) {
            if (new_head == nullptr) {
                return false;
            }

            if (old_head == old_tail) {
                tail.compare_exchange_strong(old_tail, new_head);
            }

            result = *new_head->data;

            if (head.compare_exchange_strong(old_head, new_head)) {
                delete old_head;
                return true;
            }
        }

        return false;
    }
};