这个逻辑/代码链有什么明显的问题吗

我正在读的一本书是莫里斯·赫利希和尼尔·沙维特的《多处理器编程的艺术》。在它中，有一个"无等待"队列，它（经过一点语言调整）在线程环境中进行功能测试和逻辑测试。至少，即使分布在5个线程中的10000000个项目和逻辑检查也没有冲突。

（如果无法获取项目，我编辑了队列以返回false，而不是抛出异常。下面给出了代码）。

然而，它有一个警告；队列无法增长。粗略的逻辑检查表明，如果不锁定队列，它就无法增长——这在一定程度上否定了拥有无锁队列的意义。

因此，目的是创建一个可以增长的无锁（或者至少是无饥饿锁定）队列。

因此：如果我们本质上给每个线程提供他们自己的共享队列，以一种不是矛盾修饰法的方式（并接受这一问题已经解决的高概率，并且更好地用于边做边学）：

        WaitFreeQueue<Queue<int>> queues = new WaitFreeQueue<Queue<int>>(threadCount);
        // Dequeue a queue, enqueue an item, enqueue the queue.
        // Dequeue a queue, dequeue an item, enqueue the queue.

以及无等待队列（之前的代码包含在注释中，以防我做出任何突破性的更改）：

/// <summary>
/// A wait-free queue for use in threaded environments.
/// Significantly adapted from "The Art of Multiprocessor Programming by Maurice Herlihy and Nir Shavit".
/// </summary>
/// <typeparam name="T">The type of item in the queue.</typeparam>
public class WaitFreeQueue<T>
{
    /// <summary>
    /// The index to dequeue from.
    /// </summary>
    protected int head;
    /// <summary>
    /// The index to queue to.
    /// </summary>
    protected int tail;
    /// <summary>
    /// The array to queue in.
    /// </summary>
    protected T[] items;

    /// <summary>
    /// The number of items queued.
    /// </summary>
    public int Count
    {
        get { return tail - head; }
    }

    /// <summary>
    /// Creates a new wait-free queue.
    /// </summary>
    /// <param name="capacity">The capacity of the queue.</param>
    public WaitFreeQueue(int capacity)
    {
        items = new T[capacity];
        head = 0; tail = 0;
    }

    /// <summary>
    /// Attempts to enqueue an item.
    /// </summary>
    /// <param name="value">The item to enqueue.</param>
    /// <returns>Returns false if there was no room in the queue.</returns>
    public bool Enqueue(T value)
    {
        if (tail - head == items.Length)
            // throw new IndexOutOfRangeException();
            return false;
        items[tail % items.Length] = value;
        System.Threading.Interlocked.Increment(ref tail);
        return true;
        // tail++;
    }

    /// <summary>
    /// Attempts to dequeue an item.
    /// </summary>
    /// <param name="r">The variable to dequeue to.</param>
    /// <returns>Returns true if there was an available item to dequeue.</returns>
    public bool Dequeue(out T r)
    {
        if (tail - head == 0)
        // throw new InvalidOperationException("No more items.");
        { r = default(T); return false; }
        r = items[head % items.Length];
        System.Threading.Interlocked.Increment(ref head);
        // head++;
        // return r;
        return true;
    }
}

那么：这行吗？如果没有，为什么？如果是的话，还有什么可预见的问题吗？

谢谢。