没有同步的Java等待/通知实现

Question

I have a scenario with dozens of producer and one single consumer. Timing is critical: for performance reason I want to avoid any locking of producers and I want the consumer to wait as little as possible when no messages are ready.

I've started using a ConcurrentLinkedQueue, but I don't like to call sleep on the consumer when queue.poll() == null because I could waste precious milliseconds, and I don't want to use yield because I end up wasting cpu.

So I came to implement a sort of ConcurrentBlockingQueue so that the consumer can run something like:

T item = queue.poll();
if(item == null) {
    wait();
    item = queue.poll();
}
return item;

And producer something like:

queue.offer(item);
notify();

Unfortunately wait/notify only works on synchronized block, which in turn would drastically reduce producer performance. Is there any other implementation of wait/notify mechanism that does not require synchronization?

I am aware of the risks related to not having wait and notify synchronized, and I managed to resolve them by having an external thread running the following:

while(true) {
    notify();
    sleep(100);
}

Answer 1

I've started using a ConcurrentLinkedQueue , but I don't like to call sleep on the consumer when queue.poll() == null

You should check the BlockingQueue interface , which has a take method that blocks until an item becomes available.

It has several implementations as detailed in the javadoc, but ConcurrentLinkedQueue is not one of them:

All Known Implementing Classes:
ArrayBlockingQueue, DelayQueue, LinkedBlockingDeque, LinkedBlockingQueue, LinkedTransferQueue, PriorityBlockingQueue, SynchronousQueue

Answer 2

I came out with the following implementation:

private final ConcurrentLinkedQueue<T> queue = new ConcurrentLinkedQueue<>();
private final Semaphore semaphore = new Semaphore(0);
private int size;

public void offer(T item) {
    size += 1;
    queue.offer(item);
    semaphore.release();
}

public T poll(long timeout, TimeUnit unit) {
    semaphore.drainPermits();
    T item = queue.poll();
    if (item == null) {
        try {
            semaphore.tryAcquire(timeout, unit);
        } catch (InterruptedException ex) {
        }
        item = queue.poll();
    }
    if (item == null) {
        size = 0;
    } else {
        size = Math.max(0, size - 1);
    }
    return item;
}

/** An inaccurate representation O(1)-access of queue size. */
public int size() {
    return size;
}

With the following properties:

• producers never go to SLEEP state (which I think can go with BlockingQueue implementations that use Lock in offer() , or with synchronized blocks using wait/notify)
• consumer only goes to SLEEP state when queue is empty but it is soon woken up whenever a producer offer an item (no fixed-time sleep , no yield )
• consumer can be sometime woken up even with empty queue, but it's ok here to waste some cpu cycle

Is there any equivalent implementation in jdk that I'm not aware of? Open for criticism.