--- jsr166/src/jsr166x/LinkedBlockingDeque.java 2009/11/24 03:57:04 1.4 +++ jsr166/src/jsr166x/LinkedBlockingDeque.java 2013/01/16 00:51:11 1.14 @@ -1,7 +1,7 @@ /* * Written by Doug Lea with assistance from members of JCP JSR-166 * Expert Group and released to the public domain, as explained at - * http://creativecommons.org/licenses/publicdomain + * http://creativecommons.org/publicdomain/zero/1.0/ */ package jsr166x; @@ -14,7 +14,7 @@ import java.util.concurrent.locks.*; * An optionally-bounded {@linkplain BlockingDeque blocking deque} based on * linked nodes. * - *

The optional capacity bound constructor argument serves as a + *

The optional capacity bound constructor argument serves as a * way to prevent excessive expansion. The capacity, if unspecified, * is equal to {@link Integer#MAX_VALUE}. Linked nodes are * dynamically created upon each insertion unless this would bring the @@ -39,7 +39,7 @@ import java.util.concurrent.locks.*; */ public class LinkedBlockingDeque extends AbstractQueue - implements BlockingDeque, java.io.Serializable { + implements BlockingDeque, java.io.Serializable { /* * Implemented as a simple doubly-linked list protected by a @@ -76,7 +76,7 @@ public class LinkedBlockingDeque private final Condition notFull = lock.newCondition(); /** - * Creates a LinkedBlockingDeque with a capacity of + * Creates a {@code LinkedBlockingDeque} with a capacity of * {@link Integer#MAX_VALUE}. */ public LinkedBlockingDeque() { @@ -84,10 +84,10 @@ public class LinkedBlockingDeque } /** - * Creates a LinkedBlockingDeque with the given (fixed) + * Creates a {@code LinkedBlockingDeque} with the given (fixed) * capacity. * @param capacity the capacity of this deque - * @throws IllegalArgumentException if capacity is less than 1 + * @throws IllegalArgumentException if {@code capacity} is less than 1 */ public LinkedBlockingDeque(int capacity) { if (capacity <= 0) throw new IllegalArgumentException(); @@ -95,13 +95,13 @@ public class LinkedBlockingDeque } /** - * Creates a LinkedBlockingDeque with a capacity of + * Creates a {@code LinkedBlockingDeque} with a capacity of * {@link Integer#MAX_VALUE}, initially containing the elements of the * given collection, * added in traversal order of the collection's iterator. * @param c the collection of elements to initially contain - * @throws NullPointerException if c or any element within it - * is null + * @throws NullPointerException if {@code c} or any element within it + * is {@code null} */ public LinkedBlockingDeque(Collection c) { this(Integer.MAX_VALUE); @@ -149,7 +149,7 @@ public class LinkedBlockingDeque } /** - * Remove and return first element, or null if empty + * Removes and returns first element, or null if empty. */ private E unlinkFirst() { Node f = first; @@ -167,7 +167,7 @@ public class LinkedBlockingDeque } /** - * Remove and return last element, or null if empty + * Removes and returns last element, or null if empty. */ private E unlinkLast() { Node l = last; @@ -434,8 +434,8 @@ public class LinkedBlockingDeque // BlockingQueue methods - public void put(E o) throws InterruptedException { putLast(o); } - public E take() throws InterruptedException { return takeFirst(); } + public void put(E o) throws InterruptedException { putLast(o); } + public E take() throws InterruptedException { return takeFirst(); } public boolean offer(E o, long timeout, TimeUnit unit) throws InterruptedException { return offerLast(o, timeout, unit); } public E poll(long timeout, TimeUnit unit) @@ -444,7 +444,7 @@ public class LinkedBlockingDeque /** * Returns the number of elements in this deque. * - * @return the number of elements in this deque. + * @return the number of elements in this deque */ public int size() { lock.lock(); @@ -459,11 +459,11 @@ public class LinkedBlockingDeque * Returns the number of elements that this deque can ideally (in * the absence of memory or resource constraints) accept without * blocking. This is always equal to the initial capacity of this deque - * less the current size of this deque. + * less the current {@code size} of this deque. *

Note that you cannot always tell if - * an attempt to add an element will succeed by - * inspecting remainingCapacity because it may be the - * case that a waiting consumer is ready to take an + * an attempt to {@code add} an element will succeed by + * inspecting {@code remainingCapacity} because it may be the + * case that a waiting consumer is ready to {@code take} an * element out of an otherwise full deque. */ public int remainingCapacity() { @@ -524,7 +524,7 @@ public class LinkedBlockingDeque * Variant of removeFirstOccurrence needed by iterator.remove. * Searches for the node, not its contents. */ - boolean removeNode(Node e) { + boolean removeNode(Node e) { lock.lock(); try { for (Node p = first; p != null; p = p.next) { @@ -641,13 +641,13 @@ public class LinkedBlockingDeque /** * Returns an iterator over the elements in this deque in proper sequence. - * The returned Iterator is a "weakly consistent" iterator that + * The returned {@code 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 an iterator over the elements in this deque in proper sequence. + * @return an iterator over the elements in this deque in proper sequence */ public Iterator iterator() { return new Itr(); @@ -664,7 +664,7 @@ public class LinkedBlockingDeque * an element exists in hasNext(), we must return item read * under lock (in advance()) even if it was in the process of * being removed when hasNext() was called. - **/ + */ private E nextItem; /** @@ -684,8 +684,8 @@ public class LinkedBlockingDeque final ReentrantLock lock = LinkedBlockingDeque.this.lock; lock.lock(); try { - next = (next == null)? first : next.next; - nextItem = (next == null)? null : next.item; + next = (next == null) ? first : next.next; + nextItem = (next == null) ? null : next.item; } finally { lock.unlock(); } @@ -717,10 +717,10 @@ public class LinkedBlockingDeque } /** - * Save the state to a stream (that is, serialize it). + * Saves the state to a stream (that is, serializes it). * * @serialData The capacity (int), followed by elements (each an - * Object) in the proper order, followed by a null + * {@code Object}) in the proper order, followed by a null * @param s the stream */ private void writeObject(java.io.ObjectOutputStream s) @@ -740,8 +740,8 @@ public class LinkedBlockingDeque } /** - * Reconstitute this deque instance from a stream (that is, - * deserialize it). + * Reconstitutes this deque instance from a stream (that is, + * deserializes it). * @param s the stream */ private void readObject(java.io.ObjectInputStream s)