| Methods Summary |
|---|
| public boolean | add(E o)Adds the specified element to the tail of this queue.
return offer(o);
|
| private boolean | casHead(java.util.concurrent.ConcurrentLinkedQueue$Node cmp, java.util.concurrent.ConcurrentLinkedQueue$Node val)
return headUpdater.compareAndSet(this, cmp, val);
|
| private boolean | casTail(java.util.concurrent.ConcurrentLinkedQueue$Node cmp, java.util.concurrent.ConcurrentLinkedQueue$Node val)
return tailUpdater.compareAndSet(this, cmp, val);
|
| public boolean | contains(java.lang.Object o)
if (o == null) return false;
for (Node<E> p = first(); p != null; p = p.getNext()) {
E item = p.getItem();
if (item != null &&
o.equals(item))
return true;
}
return false;
|
| java.util.concurrent.ConcurrentLinkedQueue$Node | first()Returns the first actual (non-header) node on list. This is yet
another variant of poll/peek; here returning out the first
node, not element (so we cannot collapse with peek() without
introducing race.)
for (;;) {
Node<E> h = head;
Node<E> t = tail;
Node<E> first = h.getNext();
if (h == head) {
if (h == t) {
if (first == null)
return null;
else
casTail(t, first);
} else {
if (first.getItem() != null)
return first;
else // remove deleted node and continue
casHead(h, first);
}
}
}
|
| public boolean | isEmpty()
return first() == null;
|
| public java.util.Iterator | iterator()Returns an iterator over the elements in this queue in proper sequence.
The returned iterator is a "weakly consistent" iterator that
will never throw {@link java.util.ConcurrentModificationException},
and guarantees to traverse elements as they existed upon
construction of the iterator, and may (but is not guaranteed to)
reflect any modifications subsequent to construction.
return new Itr();
|
| public boolean | offer(E o)Inserts the specified element to the tail of this queue.
if (o == null) throw new NullPointerException();
Node<E> n = new Node<E>(o, null);
for(;;) {
Node<E> t = tail;
Node<E> s = t.getNext();
if (t == tail) {
if (s == null) {
if (t.casNext(s, n)) {
casTail(t, n);
return true;
}
} else {
casTail(t, s);
}
}
}
|
| public E | peek() // same as poll except don't remove item
for (;;) {
Node<E> h = head;
Node<E> t = tail;
Node<E> first = h.getNext();
if (h == head) {
if (h == t) {
if (first == null)
return null;
else
casTail(t, first);
} else {
E item = first.getItem();
if (item != null)
return item;
else // remove deleted node and continue
casHead(h, first);
}
}
}
|
| public E | poll()
for (;;) {
Node<E> h = head;
Node<E> t = tail;
Node<E> first = h.getNext();
if (h == head) {
if (h == t) {
if (first == null)
return null;
else
casTail(t, first);
} else if (casHead(h, first)) {
E item = first.getItem();
if (item != null) {
first.setItem(null);
return item;
}
// else skip over deleted item, continue loop,
}
}
}
|
| private void | readObject(java.io.ObjectInputStream s)Reconstitute the Queue instance from a stream (that is,
deserialize it).
// Read in capacity, and any hidden stuff
s.defaultReadObject();
head = new Node<E>(null, null);
tail = head;
// Read in all elements and place in queue
for (;;) {
E item = (E)s.readObject();
if (item == null)
break;
else
offer(item);
}
|
| public boolean | remove(java.lang.Object o)
if (o == null) return false;
for (Node<E> p = first(); p != null; p = p.getNext()) {
E item = p.getItem();
if (item != null &&
o.equals(item) &&
p.casItem(item, null))
return true;
}
return false;
|
| public int | size()Returns the number of elements in this queue. If this queue
contains more than Integer.MAX_VALUE elements, returns
Integer.MAX_VALUE.
Beware that, unlike in most collections, this method is
NOT a constant-time operation. Because of the
asynchronous nature of these queues, determining the current
number of elements requires an O(n) traversal.
int count = 0;
for (Node<E> p = first(); p != null; p = p.getNext()) {
if (p.getItem() != null) {
// Collections.size() spec says to max out
if (++count == Integer.MAX_VALUE)
break;
}
}
return count;
|
| public java.lang.Object[] | toArray()
// Use ArrayList to deal with resizing.
ArrayList<E> al = new ArrayList<E>();
for (Node<E> p = first(); p != null; p = p.getNext()) {
E item = p.getItem();
if (item != null)
al.add(item);
}
return al.toArray();
|
| public T[] | toArray(T[] a)
// try to use sent-in array
int k = 0;
Node<E> p;
for (p = first(); p != null && k < a.length; p = p.getNext()) {
E item = p.getItem();
if (item != null)
a[k++] = (T)item;
}
if (p == null) {
if (k < a.length)
a[k] = null;
return a;
}
// If won't fit, use ArrayList version
ArrayList<E> al = new ArrayList<E>();
for (Node<E> q = first(); q != null; q = q.getNext()) {
E item = q.getItem();
if (item != null)
al.add(item);
}
return (T[])al.toArray(a);
|
| private void | writeObject(java.io.ObjectOutputStream s)Save the state to a stream (that is, serialize it).
// Write out any hidden stuff
s.defaultWriteObject();
// Write out all elements in the proper order.
for (Node<E> p = first(); p != null; p = p.getNext()) {
Object item = p.getItem();
if (item != null)
s.writeObject(item);
}
// Use trailing null as sentinel
s.writeObject(null);
|
