ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/jsr166/jsr166/src/jsr166y/LinkedTransferQueue.java

Comparing jsr166/src/jsr166y/LinkedTransferQueue.java (file contents):
Revision 1.19 by jsr166, Tue Jul 21 00:15:14 2009 UTC vs.
Revision 1.22 by jsr166, Thu Jul 23 19:25:45 2009 UTC

#	Line 44 | Line 44 | import java.lang.reflect.*;
44		* @since 1.7
45		* @author Doug Lea
46		* @param <E> the type of elements held in this collection
47	–	*
47		*/
48		public class LinkedTransferQueue<E> extends AbstractQueue<E>
49		implements TransferQueue<E>, java.io.Serializable {
#	Line 81 | Line 80 | public class LinkedTransferQueue<E> exte
80		* seems not to vary with number of CPUs (beyond 2) so is just
81		* a constant.
82		*/
83	<	static final int maxTimedSpins = (NCPUS < 2)? 0 : 32;
83	>	static final int maxTimedSpins = (NCPUS < 2) ? 0 : 32;
84
85		/**
86		* The number of times to spin before blocking in untimed waits.
#	Line 203 | Line 202 | public class LinkedTransferQueue<E> exte
202		Object x = first.get();
203		if (x != first && first.compareAndSet(x, e)) {
204		LockSupport.unpark(first.waiter);
205	<	return isData? e : x;
205	>	return isData ? e : x;
206		}
207		}
208		}
#	Line 241 | Line 240 | public class LinkedTransferQueue<E> exte
240		Object x = first.get();
241		if (x != first && first.compareAndSet(x, e)) {
242		LockSupport.unpark(first.waiter);
243	<	return isData? e : x;
243	>	return isData ? e : x;
244		}
245		}
246		}
#	Line 264 | Line 263 | public class LinkedTransferQueue<E> exte
263		if (mode == NOWAIT)
264		return null;
265
266	<	long lastTime = (mode == TIMEOUT)? System.nanoTime() : 0;
266	>	long lastTime = (mode == TIMEOUT) ? System.nanoTime() : 0;
267		Thread w = Thread.currentThread();
268		int spins = -1; // set to desired spin count below
269		for (;;) {
#	Line 296 | Line 295 | public class LinkedTransferQueue<E> exte
295		if (spins < 0) {
296		QNode h = head.get(); // only spin if at head
297		spins = ((h != null && h.next == s) ?
298	<	(mode == TIMEOUT?
298	>	((mode == TIMEOUT) ?
299		maxTimedSpins : maxUntimedSpins) : 0);
300		}
301		if (spins > 0)
#	Line 487 | Line 486 | public class LinkedTransferQueue<E> exte
486		public E take() throws InterruptedException {
487		Object e = xfer(null, WAIT, 0);
488		if (e != null)
489	<	return (E)e;
489	>	return (E) e;
490		Thread.interrupted();
491		throw new InterruptedException();
492		}
#	Line 495 | Line 494 | public class LinkedTransferQueue<E> exte
494		public E poll(long timeout, TimeUnit unit) throws InterruptedException {
495		Object e = xfer(null, TIMEOUT, unit.toNanos(timeout));
496		if (e != null || !Thread.interrupted())
497	<	return (E)e;
497	>	return (E) e;
498		throw new InterruptedException();
499		}
500
501		public E poll() {
502	<	return (E)fulfill(null);
502	>	return (E) fulfill(null);
503		}
504
505		public int drainTo(Collection<? super E> c) {
#	Line 603 | Line 602 | public class LinkedTransferQueue<E> exte
602		Object x = q.get();
603		QNode s = q.next;
604		if (x != null && q != x && q != s) {
605	<	nextItem = (E)x;
605	>	nextItem = (E) x;
606		snext = s;
607		pnext = pred;
608		next = q;
#	Line 650 | Line 649 | public class LinkedTransferQueue<E> exte
649		if (!p.isData)
650		return null;
651		if (x != null)
652	<	return (E)x;
652	>	return (E) x;
653		}
654		}
655		}
#	Line 773 | Line 772 | public class LinkedTransferQueue<E> exte
772		s.defaultReadObject();
773		resetHeadAndTail();
774		for (;;) {
775	<	E item = (E)s.readObject();
775	>	E item = (E) s.readObject();
776		if (item == null)
777		break;
778		else
#	Line 785 | Line 784 | public class LinkedTransferQueue<E> exte
784		// Support for resetting head/tail while deserializing
785		private void resetHeadAndTail() {
786		QNode dummy = new QNode(null, false);
787	<	_unsafe.putObjectVolatile(this, headOffset,
787	>	UNSAFE.putObjectVolatile(this, headOffset,
788		new PaddedAtomicReference<QNode>(dummy));
789	<	_unsafe.putObjectVolatile(this, tailOffset,
789	>	UNSAFE.putObjectVolatile(this, tailOffset,
790		new PaddedAtomicReference<QNode>(dummy));
791	<	_unsafe.putObjectVolatile(this, cleanMeOffset,
791	>	UNSAFE.putObjectVolatile(this, cleanMeOffset,
792		new PaddedAtomicReference<QNode>(null));
793		}
794
#	Line 819 | Line 818 | public class LinkedTransferQueue<E> exte
818
819		private static long fieldOffset(String fieldName)
820		throws NoSuchFieldException {
821	<	return _unsafe.objectFieldOffset
821	>	return UNSAFE.objectFieldOffset
822		(LinkedTransferQueue.class.getDeclaredField(fieldName));
823		}
824
825	<	private static final Unsafe _unsafe;
825	>	private static final Unsafe UNSAFE;
826		private static final long headOffset;
827		private static final long tailOffset;
828		private static final long cleanMeOffset;
829		static {
830		try {
831	<	_unsafe = getUnsafe();
831	>	UNSAFE = getUnsafe();
832		headOffset = fieldOffset("head");
833		tailOffset = fieldOffset("tail");
834		cleanMeOffset = fieldOffset("cleanMe");

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines