jdk-sandbox: comparison jdk/src/share/classes/java/util/concurrent/LinkedTransferQueue.java

equal deleted inserted replaced

-:e3a1c90dd439
+:d9dab5ec5044
 *    heavily contended queues. And so long as it is relatively
 *    brief and "quiet", spinning does not much impact performance
 *    of less-contended queues.  During spins threads check their
 *    interrupt status and generate a thread-local random number
 *    to decide to occasionally perform a Thread.yield. While
-*    yield has underdefined specs, we assume that might it help,
+*    yield has underdefined specs, we assume that it might help,
-*    and will not hurt in limiting impact of spinning on busy
+*    and will not hurt, in limiting impact of spinning on busy
 *    systems.  We also use smaller (1/2) spins for nodes that are
 *    not known to be front but whose predecessors have not
 *    blocked -- these "chained" spins avoid artifacts of
 *    front-of-queue rules which otherwise lead to alternating
 *    nodes spinning vs blocking. Further, front threads that
 private static final long nextOffset;
 private static final long waiterOffset;
 static {
 try {
 UNSAFE = sun.misc.Unsafe.getUnsafe();
-Class k = Node.class;
+Class<?> k = Node.class;
 itemOffset = UNSAFE.objectFieldOffset
 (k.getDeclaredField("item"));
 nextOffset = UNSAFE.objectFieldOffset
 (k.getDeclaredField("next"));
 waiterOffset = UNSAFE.objectFieldOffset
 if ((h = head)   == null ||
 (q = h.next) == null || !q.isMatched())
 break;        // unless slack < 2
 }
 LockSupport.unpark(p.waiter);
-return this.<E>cast(item);
+return LinkedTransferQueue.<E>cast(item);
 }
 }
 Node n = p.next;
 p = (p != n) ? n : (h = head); // Use head if p offlist
 }
 for (;;) {
 Object item = s.item;
 if (item != e) {                  // matched
 // assert item != s;
 s.forgetContents();           // avoid garbage
-return this.<E>cast(item);
+return LinkedTransferQueue.<E>cast(item);
 }
 if ((w.isInterrupted() || (timed && nanos <= 0)) &&
 s.casItem(e, s)) {        // cancel
 unsplice(pred, s);
 return e;
 private E firstDataItem() {
 for (Node p = head; p != null; p = succ(p)) {
 Object item = p.item;
 if (p.isData) {
 if (item != null && item != p)
-return this.<E>cast(item);
+return LinkedTransferQueue.<E>cast(item);
 }
 else if (item == null)
 return null;
 }
 return null;
 }
 }
 return false;
 }
 /**
 * Creates an initially empty {@code LinkedTransferQueue}.
 */
 public LinkedTransferQueue() {
 }
 * Inserts the specified element at the tail of this queue.
 * As the queue is unbounded, this method will never block or
 * return {@code false}.
 *
 * @return {@code true} (as specified by
-*  {@link BlockingQueue#offer(Object,long,TimeUnit) BlockingQueue.offer})
+*  {@link java.util.concurrent.BlockingQueue#offer(Object,long,TimeUnit)
+*  BlockingQueue.offer})
 * @throws NullPointerException if the specified element is null
 */
 public boolean offer(E e, long timeout, TimeUnit unit) {
 xfer(e, true, ASYNC, 0);
 return true;
 if (c == null)
 throw new NullPointerException();
 if (c == this)
 throw new IllegalArgumentException();
 int n = 0;
-E e;
+for (E e; (e = poll()) != null;) {
-while ( (e = poll()) != null) {
 c.add(e);
 ++n;
 }
 return n;
 }
 if (c == null)
 throw new NullPointerException();
 if (c == this)
 throw new IllegalArgumentException();
 int n = 0;
-E e;
+for (E e; n < maxElements && (e = poll()) != null;) {
-while (n < maxElements && (e = poll()) != null) {
 c.add(e);
 ++n;
 }
 return n;
 }
 /**
 * Always returns {@code Integer.MAX_VALUE} because a
 * {@code LinkedTransferQueue} is not capacity constrained.
 *
 * @return {@code Integer.MAX_VALUE} (as specified by
-*         {@link BlockingQueue#remainingCapacity()})
+*         {@link java.util.concurrent.BlockingQueue#remainingCapacity()
+*         BlockingQueue.remainingCapacity})
 */
 public int remainingCapacity() {
 return Integer.MAX_VALUE;
 }
 */
 private void readObject(java.io.ObjectInputStream s)
 throws java.io.IOException, ClassNotFoundException {
 s.defaultReadObject();
 for (;;) {
-@SuppressWarnings("unchecked") E item = (E) s.readObject();
+@SuppressWarnings("unchecked")
+E item = (E) s.readObject();
 if (item == null)
 break;
 else
 offer(item);
 }
 private static final long tailOffset;
 private static final long sweepVotesOffset;
 static {
 try {
 UNSAFE = sun.misc.Unsafe.getUnsafe();
-Class k = LinkedTransferQueue.class;
+Class<?> k = LinkedTransferQueue.class;
 headOffset = UNSAFE.objectFieldOffset
 (k.getDeclaredField("head"));
 tailOffset = UNSAFE.objectFieldOffset
 (k.getDeclaredField("tail"));
 sweepVotesOffset = UNSAFE.objectFieldOffset

changeset 11279	d9dab5ec5044
parent 9515	04056ec0f477
child 14325	622c473a21aa