This
class
is a threadsafe implementation of the
java.util.Queue interface (but not of the
BlockingQueue interface). It provides threadsafety
without using synchronized methods that would lock
the entire data structure. ConcurrentLinkedQueue
is unbounded and orders its elements on a first-in, first-out (FIFO)
basis. null elements are not allowed. This
implementation uses a linked-list data structure internally. Note
that the size( ) method must traverse the internal
data structure and is therefore a relatively expensive operation for
this class.
Figure 16-76. java.util.concurrent.ConcurrentLinkedQueue<E>
public class
ConcurrentLinkedQueue<E> extends java.util.AbstractQueue<E>
implements java.util.Queue<E>, Serializable {
// Public Constructors
public
ConcurrentLinkedQueue ( );
public
ConcurrentLinkedQueue (java.util.Collection<? extends E>
c );
// Methods Implementing Collection
public boolean
add (E
o );
public boolean
contains (Object
o );
public boolean
isEmpty ( ); default:true
public java.util.Iterator<E>
iterator ( );
public boolean
remove (Object
o );
public int
size ( );
public Object[ ]
toArray ( );
public <T> T[ ]
toArray (T[ ]
a );
// Methods Implementing Queue
public boolean
offer (E
o );
public E
peek ( );
public E
poll ( );
}