如何使CircularFifoQueue线程安全？

Question

I'd like to use a CircularFifoQueue with spring ExecutorService .

The following does not compile, because CircularFifoQueue is not of type BlockingQueue . But it shows what I'm trying to achieve:

int threads = 10;
int queueSize = 500;
new java.util.concurrent.ThreadPoolExecutor(threads, threads, 0L, TimeUnit.MILLISECONDS, 
                new CircularFifoQueue(queueSize));

With:

package org.apache.commons.collections4.queue;

public class CircularFifoQueue<E> extends AbstractCollection<E>
       implements Queue<E>, BoundedCollection<E>, Serializable

Question: does the code above provide thread safety (as CircularFifoQueue itself is not threadsafe)? If not, how can I make it threadsafe?

Answer 1

Work queues are meant to be blocking, and hence you would need to add a decorator to make that CircularFifoQueue a BLockingQueue .

class BlockingCircularFifoQueue<E> implements BlockingQueue<E>{
  private CircularFifoQueue<E> backingCollection;
  ...
} 

And delegate to the backing collection when needed. You would need to get Conditions and Lock right of course.

Answer 2

You will have to practically write your own queue implementation. Since CircularFifoQueue uses an underlying array to hold the elements, I would take help of the ArrayBlockingQueue data structure in java.util.concurrent package as a starting point.

Example :

class ThreadSafeCircularFifoQueue<T> extends CircularFifoQueue<T> implements BlockingQueue<T> {

    /** Main lock guarding all access */
    final ReentrantLock lock;

    /** Condition for waiting takes */
    private final Condition notEmpty;

    /** Condition for waiting puts */
    private final Condition notFull;

    @Override
    public int size() {

        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            return super.size();
        } finally {
            lock.unlock();
        }
    }

    //and so forth
}

Answer 3

You can synchronize using commons-collections QueueUtils.synchronizedQueue

Queue queue = QueueUtils.synchronizedQueue(new CircularFifoQueue());

But according to javadoc it needs additional synchronization for serial access:

In order to guarantee serial access, it is critical that all access to the backing queue is accomplished through the returned queue.

It is imperative that the user manually synchronize on the returned queue when iterating over it:

 Queue queue = QueueUtils.synchronizedQueue(new CircularFifoQueue()); ... synchronized(queue) { Iterator i = queue.iterator(); // Must be in synchronized block while (i.hasNext()) foo(i.next()); } } 

Failure to follow this advice may result in non-deterministic behavior.