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( );  
}