This BlockingQueue implementation is the degenerate case of a bounded queue with a capacity of zero. Every call to put( ) blocks until a corresponding call to take( ) , and vice versa. You can think of this as an Exchanger that does only a one-way exchange. The size ( ) and remainingCapacity( ) methods always return 0. The peek( ) method always returns null . The iterator( ) method returns an Iterator for which the hasNext( ) method returns false . Figure 16-93. java.util.concurrent.SynchronousQueue<E>public class SynchronousQueue<E> extends java.util.AbstractQueue<E> implements BlockingQueue<E>, Serializable { // Public Constructors public SynchronousQueue ( ); public SynchronousQueue (boolean fair ); // Methods Implementing BlockingQueue public int drainTo (java.util.Collection<? super E> c ); public int drainTo (java.util.Collection<? super E> c , int maxElements ); public boolean offer (E o ); public boolean offer (E o , long timeout , TimeUnit unit ) throws InterruptedException; public E poll (long timeout , TimeUnit unit ) throws InterruptedException; public void put (E o ) throws InterruptedException; public int remainingCapacity ( ); constant public E take ( ) throws InterruptedException; // Methods Implementing Collection public void clear ( ); empty public boolean contains (Object o ); constant public boolean containsAll (java.util.Collection<?> c ); public boolean isEmpty ( ); constant default:true public java.util.Iterator<E> iterator ( ); public boolean remove (Object o ); constant public boolean removeAll (java.util.Collection<?> c ); constant public boolean retainAll (java.util.Collection<?> c ); constant public int size ( ); constant public Object[ ] toArray ( ); public <T> T[ ] toArray (T[ ] a ); // Methods Implementing Queue public E peek ( ); constant public E poll ( ); } |