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.24 by jsr166, Thu Jul 23 23:23:41 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 124 | Line 123 | public class LinkedTransferQueue<E> exte
123		nextUpdater.lazySet(this, this);
124		}
125
126	+	private static final long serialVersionUID = -3375979862319811754L;
127		}
128
129		/**
#	Line 135 | Line 135 | public class LinkedTransferQueue<E> exte
135		// enough padding for 64bytes with 4byte refs
136		Object p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, pa, pb, pc, pd, pe;
137		PaddedAtomicReference(T r) { super(r); }
138	+	private static final long serialVersionUID = 8170090609809740854L;
139		}
140
141
142		/** head of the queue */
143		private transient final PaddedAtomicReference<QNode> head;
144	+
145		/** tail of the queue */
146		private transient final PaddedAtomicReference<QNode> tail;
147
#	Line 203 | Line 205 | public class LinkedTransferQueue<E> exte
205		Object x = first.get();
206		if (x != first && first.compareAndSet(x, e)) {
207		LockSupport.unpark(first.waiter);
208	<	return isData? e : x;
208	>	return isData ? e : x;
209		}
210		}
211		}
#	Line 241 | Line 243 | public class LinkedTransferQueue<E> exte
243		Object x = first.get();
244		if (x != first && first.compareAndSet(x, e)) {
245		LockSupport.unpark(first.waiter);
246	<	return isData? e : x;
246	>	return isData ? e : x;
247		}
248		}
249		}
#	Line 264 | Line 266 | public class LinkedTransferQueue<E> exte
266		if (mode == NOWAIT)
267		return null;
268
269	<	long lastTime = (mode == TIMEOUT)? System.nanoTime() : 0;
269	>	long lastTime = (mode == TIMEOUT) ? System.nanoTime() : 0;
270		Thread w = Thread.currentThread();
271		int spins = -1; // set to desired spin count below
272		for (;;) {
#	Line 296 | Line 298 | public class LinkedTransferQueue<E> exte
298		if (spins < 0) {
299		QNode h = head.get(); // only spin if at head
300		spins = ((h != null && h.next == s) ?
301	<	(mode == TIMEOUT?
301	>	((mode == TIMEOUT) ?
302		maxTimedSpins : maxUntimedSpins) : 0);
303		}
304		if (spins > 0)
#	Line 487 | Line 489 | public class LinkedTransferQueue<E> exte
489		public E take() throws InterruptedException {
490		Object e = xfer(null, WAIT, 0);
491		if (e != null)
492	<	return (E)e;
492	>	return (E) e;
493		Thread.interrupted();
494		throw new InterruptedException();
495		}
#	Line 495 | Line 497 | public class LinkedTransferQueue<E> exte
497		public E poll(long timeout, TimeUnit unit) throws InterruptedException {
498		Object e = xfer(null, TIMEOUT, unit.toNanos(timeout));
499		if (e != null || !Thread.interrupted())
500	<	return (E)e;
500	>	return (E) e;
501		throw new InterruptedException();
502		}
503
504		public E poll() {
505	<	return (E)fulfill(null);
505	>	return (E) fulfill(null);
506		}
507
508		public int drainTo(Collection<? super E> c) {
#	Line 603 | Line 605 | public class LinkedTransferQueue<E> exte
605		Object x = q.get();
606		QNode s = q.next;
607		if (x != null && q != x && q != s) {
608	<	nextItem = (E)x;
608	>	nextItem = (E) x;
609		snext = s;
610		pnext = pred;
611		next = q;
#	Line 650 | Line 652 | public class LinkedTransferQueue<E> exte
652		if (!p.isData)
653		return null;
654		if (x != null)
655	<	return (E)x;
655	>	return (E) x;
656		}
657		}
658		}
#	Line 773 | Line 775 | public class LinkedTransferQueue<E> exte
775		s.defaultReadObject();
776		resetHeadAndTail();
777		for (;;) {
778	<	E item = (E)s.readObject();
778	>	E item = (E) s.readObject();
779		if (item == null)
780		break;
781		else
#	Line 785 | Line 787 | public class LinkedTransferQueue<E> exte
787		// Support for resetting head/tail while deserializing
788		private void resetHeadAndTail() {
789		QNode dummy = new QNode(null, false);
790	<	_unsafe.putObjectVolatile(this, headOffset,
790	>	UNSAFE.putObjectVolatile(this, headOffset,
791		new PaddedAtomicReference<QNode>(dummy));
792	<	_unsafe.putObjectVolatile(this, tailOffset,
792	>	UNSAFE.putObjectVolatile(this, tailOffset,
793		new PaddedAtomicReference<QNode>(dummy));
794	<	_unsafe.putObjectVolatile(this, cleanMeOffset,
794	>	UNSAFE.putObjectVolatile(this, cleanMeOffset,
795		new PaddedAtomicReference<QNode>(null));
796		}
797
#	Line 819 | Line 821 | public class LinkedTransferQueue<E> exte
821
822		private static long fieldOffset(String fieldName)
823		throws NoSuchFieldException {
824	<	return _unsafe.objectFieldOffset
824	>	return UNSAFE.objectFieldOffset
825		(LinkedTransferQueue.class.getDeclaredField(fieldName));
826		}
827
828	<	private static final Unsafe _unsafe;
828	>	private static final Unsafe UNSAFE;
829		private static final long headOffset;
830		private static final long tailOffset;
831		private static final long cleanMeOffset;
832		static {
833		try {
834	<	_unsafe = getUnsafe();
834	>	UNSAFE = getUnsafe();
835		headOffset = fieldOffset("head");
836		tailOffset = fieldOffset("tail");
837		cleanMeOffset = fieldOffset("cleanMe");

Diff Legend

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