线程安全队列：无锁实现还是阻塞队列更可靠？

// 一个简单的基于CAS的无锁队列（简化版，仅供参考）
public class LockFreeQueue<T> {
    private final AtomicReference<Node<T>> head;
    private final AtomicReference<Node<T>> tail;

    public LockFreeQueue() {
        Node<T> dummy = new Node<>(null);
        head = new AtomicReference<>(dummy);
        tail = new AtomicReference<>(dummy);
    }

    public void enqueue(T data) {
        Node<T> newNode = new Node<>(data);
        while (true) {
            Node<T> curTail = tail.get();
            Node<T> tailNext = curTail.next.get();
            if (curTail == tail.get()) {
                if (tailNext != null) {
                    // 队列处于中间状态，帮助推进tail
                    tail.compareAndSet(curTail, tailNext);
                } else {
                    // 尝试将新节点添加到队列尾部
                    if (curTail.next.compareAndSet(null, newNode)) {
                        tail.compareAndSet(curTail, newNode);
                        return;
                    }
                }
            }
        }
    }

    // ... (dequeue方法类似，也需要使用CAS操作)

    private static class Node<T> {
        final T data;
        final AtomicReference<Node<T>> next;

        Node(T data) {
            this.data = data;
            this.next = new AtomicReference<>(null);
        }
    }
}

// 一个简单的阻塞队列（简化版，仅供参考）
public class BlockingQueue<T> {
    private final Queue<T> queue = new LinkedList<>();
    private final int capacity;
    private final Object notFull = new Object();
    private final Object notEmpty = new Object();

    public BlockingQueue(int capacity) {
        this.capacity = capacity;
    }

    public synchronized void enqueue(T data) throws InterruptedException {
        synchronized (notFull) {
            while (queue.size() == capacity) {
                notFull.wait();
            }
        }
        queue.add(data);
        synchronized (notEmpty) {
            notEmpty.notify();
        }
    }

    public synchronized T dequeue() throws InterruptedException {
        synchronized (notEmpty) {
            while (queue.isEmpty()) {
                notEmpty.wait();
            }
        }
        T data = queue.remove();
        synchronized (notFull) {
            notFull.notify();
        }
        return data;
    }
}