这是（无锁）队列实现线程安全的吗？

Question

我正在尝试用Java创建一个无锁队列实现，主要用于个人学习。队列应该是一个通用队列，允许同时有任意数量的读取器和/或写入器。

能否请您检查一下，并提出您发现的任何改进/问题？

谢谢。

import java.util.concurrent.atomic.AtomicReference;

public class LockFreeQueue<T> {
    private static class Node<E> {
        E value;
        volatile Node<E> next;

        Node(E value) {
            this.value = value;
        }
    }

    private AtomicReference<Node<T>> head, tail;

    public LockFreeQueue() {
        // have both head and tail point to a dummy node
        Node<T> dummyNode = new Node<T>(null);
        head = new AtomicReference<Node<T>>(dummyNode);
        tail = new AtomicReference<Node<T>>(dummyNode);
    }

    /**
     * Puts an object at the end of the queue.
     */
    public void putObject(T value) {
        Node<T> newNode = new Node<T>(value);
        Node<T> prevTailNode = tail.getAndSet(newNode);
        prevTailNode.next = newNode;
    }

    /**
     * Gets an object from the beginning of the queue. The object is removed
     * from the queue. If there are no objects in the queue, returns null.
     */
    public T getObject() {
        Node<T> headNode, valueNode;

        // move head node to the next node using atomic semantics
        // as long as next node is not null
        do {
            headNode = head.get();
            valueNode = headNode.next;
            // try until the whole loop executes pseudo-atomically
            // (i.e. unaffected by modifications done by other threads)
        } while (valueNode != null && !head.compareAndSet(headNode, valueNode));

        T value = (valueNode != null ? valueNode.value : null);

        // release the value pointed to by head, keeping the head node dummy
        if (valueNode != null)
            valueNode.value = null;

        return value;
}

Answer 1

你应该看看 java.util.concurrent.ConcurrentLinkedQueue 的实现 http://java.sun.com/j2se/1.5.0/docs/api/java/util/concurrent/ConcurrentLinkedQueue.html 它几乎可以实现您想要实现的目标

Answer 2

我相信当你尝试“释放价值......”时，如果你调用，你会得到一个 NPE

new LockFreeQueue<?>().getObject();

因为您没有对那里的valueNode 执行任何无效检查，尽管上面有所防范。

Answer 3

代码不是线程安全的。考虑putObject(...)：

public void putObject(T value) {
    Node<T> newNode = new Node<T>(value);
    Node<T> prevTailNode = tail.getAndSet(newNode);
    prevTailNode.next = newNode;
}

第二条语句在设置前一个节点的next 指针之前添加新节点。这只发生在第三条语句中。因此，有一个窗口，其中next 是null；即竞争条件。

即使你解决了这个问题，还有一个更隐蔽的问题。读取 Node 对象的next 字段的线程不会必然看到第二个线程刚刚写入的值。这是 Java 内存模型的结果。在这种情况下，确保以下读取始终看到较早写入的值的方法是：

• 将next 声明为volatile，或者
• 在同一个对象的原始互斥体中进行读取和写入。

编辑：在更详细地阅读getObject() 和putObject() 的代码时，我可以看到没有任何东西会强制next 的非空值被刷新到putObject 中的内存中，并且没有任何东西强制@ 987654333@ 从主存读取next。所以getObject 代码可能会看到错误的next 值，导致它在队列中确实有一个元素时返回null。

Answer 4

我发现您的代码只有两个问题：

• 一个是内存操作顺序Stephen C提到的问题（可以通过声明next和valuevolatile来解决）（Node:value也有同样的问题）

• second 是一个更微妙的，与并发无关：在 getObject 返回一个对象后，您仍然保留它来自 head 的引用。这可能会导致内存泄漏。

否则算法正常。一个模糊的演示（假设以上是固定的）：

L1：tail 永远无法从队列中删除。这是因为当某些东西存储在tail 中时，它有next == null。此外，当您将某些内容分配给xxx.next（仅在putObject 中）时，它不能是tail，因为getAndSet 的原子性以及易失性写入和后续读取之间的顺序 - 假设您读取非空tail.next ，这个值一定是由putObject写的，因此happens-after是它的最后一行。这意味着它发生在上一行之后，这意味着我们正在读取的值不是来自tail。

其结果是putObject 中的每个对象最终都可以从head 访问。那是因为我们是在tail之后连接的，而这个节点只有在我们将新节点的引用写入它的next之后才能删除，这意味着新节点可以从head到达。

添加的对象通过putObject 中的getAndSet 操作进行简单排序。

出队的对象根据getObject中成功的compareAndSet操作进行排序。

getObject/putObject 是根据对 volatile 字段next 的写入/读取排序的。