阻塞和非阻塞队列

Question

我为阻塞和非阻塞队列实现提供了以下内容。请提出任何修改/改进/解决办法。

阻塞队列：

public class BlockingQueue<T> {
    List<T> buffer;
    private static final int MAX_QUEUE_SIZE = 100;

    public BlockingQueue() {
        buffer = new ArrayList<T>();
    }

    public void enqueue(T value) throws InterruptedException {
        synchronized(buffer) {
            while(buffer.size() >= MAX_QUEUE_SIZE) {
                buffer.wait();
            }
            buffer.add(value);
            buffer.notifyAll();
        }
    }

    public T dequeue() throws InterruptedException {
        synchronized(buffer) {
            while(buffer.size() < 1) {
                buffer.wait();
            }
            T value = buffer.remove(0);
            buffer.notifyAll();
            return value;
        }
    }

}

非阻塞队列：

public class NonBlockingQueue<T> {
    List<T> buffer;
    private static final int MAX_QUEUE_SIZE = 100;
    private AtomicBoolean mutex = new AtomicBoolean(false);

    public NonBlockingQueue() {
        buffer = new ArrayList<T>();
    }

    public void enqueue(T value) throws InterruptedException {
        while(true) {
            while(!mutex.compareAndSet(false, true)) {
                Thread.sleep(100);
            }
            if(buffer.size() < MAX_QUEUE_SIZE) {
                buffer.add(value);
                mutex.set(false);
                return;
            } else {
                mutex.set(false);
            }
        }

    }

    public T dequeue() throws InterruptedException {
        T value = null;
        while(true) {
            while(!mutex.compareAndSet(false, true)) {
                Thread.sleep(100);
            }
            if(buffer.size() > 0) {
                value = buffer.remove(0);
                mutex.set(false);
                return value;
            } else {
                mutex.set(false);
            }
        }   
    }
}

我认为非阻塞意味着线程不应该被阻塞，所以我使用了sleep方法。如果有什么问题请告诉我。

Answer 1

你要求批评..。

1. 为什么要使用AtomicBoolean作为互斥对象？如果需要更复杂的行为，可以使用原始锁或Lock。
2. (几乎)任何时候在算法中使用sleep，都是错误的。在这种情况下，“错误的方式”是以上第1点的直接后果。
3. 如果您希望在有多个生产者和消费者的情况下具有良好的性能，则应该避免执行notifyAll。例如，如果有N个消费者在等待，并且生产者添加了一个队列条目，那么所有N个消费者都会被唤醒。理想情况下，只有一个消费者应该被唤醒。

Answer 2

因为您将在结束时进行大量的添加，并且(特别是)从一开始就删除，所以我将使用LinkedList而不是ArrayList。

我也不知道是什么使你的NonBlockingQueue非阻塞。它在睡觉，这也很好。