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.15 by dl, Wed Mar 25 13:43:42 2009 UTC vs.
Revision 1.20 by jsr166, Tue Jul 21 18:11:44 2009 UTC

#	Line 166 | Line 166 | public class LinkedTransferQueue<E> exte
166		* Puts or takes an item. Used for most queue operations (except
167		* poll() and tryTransfer()). See the similar code in
168		* SynchronousQueue for detailed explanation.
169	+	*
170		* @param e the item or if null, signifies that this is a take
171		* @param mode the wait mode: NOWAIT, TIMEOUT, WAIT
172		* @param nanos timeout in nanosecs, used only if mode is TIMEOUT
#	Line 212 | Line 213 | public class LinkedTransferQueue<E> exte
213
214		/**
215		* Version of xfer for poll() and tryTransfer, which
216	<	* simplifies control paths both here and in xfer
216	>	* simplifies control paths both here and in xfer.
217		*/
218		private Object fulfill(Object e) {
219		boolean isData = (e != null);
#	Line 272 | Line 273 | public class LinkedTransferQueue<E> exte
273		Object x = s.get();
274		if (x != e) {                 // Node was matched or cancelled
275		advanceHead(pred, s);     // unlink if head
276	<	if (x == s) {              // was cancelled
276	>	if (x == s) {             // was cancelled
277		clean(pred, s);
278		return null;
279		}
#	Line 316 | Line 317 | public class LinkedTransferQueue<E> exte
317		}
318
319		/**
320	<	* Returns validated tail for use in cleaning methods
320	>	* Returns validated tail for use in cleaning methods.
321		*/
322		private QNode getValidatedTail() {
323		for (;;) {
#	Line 339 | Line 340 | public class LinkedTransferQueue<E> exte
340
341		/**
342		* Gets rid of cancelled node s with original predecessor pred.
343	+	*
344		* @param pred predecessor of cancelled node
345		* @param s the cancelled node
346		*/
#	Line 378 | Line 380 | public class LinkedTransferQueue<E> exte
380		/**
381		* Tries to unsplice the cancelled node held in cleanMe that was
382		* previously uncleanable because it was at tail.
383	+	*
384		* @return current cleanMe node (or null)
385		*/
386		private QNode reclean() {
#	Line 422 | Line 425 | public class LinkedTransferQueue<E> exte
425		* Creates a {@code LinkedTransferQueue}
426		* initially containing the elements of the given collection,
427		* added in traversal order of the collection's iterator.
428	+	*
429		* @param c the collection of elements to initially contain
430		* @throws NullPointerException if the specified collection or any
431		*         of its elements are null
#	Line 530 | Line 534 | public class LinkedTransferQueue<E> exte
534		// Traversal-based methods
535
536		/**
537	<	* Return head after performing any outstanding helping steps
537	>	* Returns head after performing any outstanding helping steps.
538		*/
539		private QNode traversalHead() {
540		for (;;) {
#	Line 575 | Line 579 | public class LinkedTransferQueue<E> exte
579		QNode snext;       // successor of next
580		QNode curr;        // last returned node, for remove()
581		QNode pcurr;       // predecessor of curr, for remove()
582	<	E nextItem;        // Cache of next item, once commited to in next
582	>	E nextItem;        // Cache of next item, once committed to in next
583
584		Itr() {
585		findNext();
586		}
587
588		/**
589	<	* Ensure next points to next valid node, or null if none.
589	>	* Ensures next points to next valid node, or null if none.
590		*/
591		void findNext() {
592		for (;;) {
#	Line 732 | Line 736 | public class LinkedTransferQueue<E> exte
736		if (q == pred) // restart
737		break;
738		Object x = q.get();
739	<	if (x != null && x != q && o.equals(x) &&
739	>	if (x != null && x != q && o.equals(x) &&
740		q.compareAndSet(x, q)) {
741		clean(pred, q);
742		return true;
#	Line 752 | Line 756 | public class LinkedTransferQueue<E> exte
756		private void writeObject(java.io.ObjectOutputStream s)
757		throws java.io.IOException {
758		s.defaultWriteObject();
759	<	for (Iterator<E> it = iterator(); it.hasNext(); )
760	<	s.writeObject(it.next());
759	>	for (E e : this)
760	>	s.writeObject(e);
761		// Use trailing null as sentinel
762		s.writeObject(null);
763		}
#	Line 761 | Line 765 | public class LinkedTransferQueue<E> exte
765		/**
766		* Reconstitute the Queue instance from a stream (that is,
767		* deserialize it).
768	+	*
769		* @param s the stream
770		*/
771		private void readObject(java.io.ObjectInputStream s)
#	Line 780 | Line 785 | public class LinkedTransferQueue<E> exte
785		// Support for resetting head/tail while deserializing
786		private void resetHeadAndTail() {
787		QNode dummy = new QNode(null, false);
788	<	_unsafe.putObjectVolatile(this, headOffset,
788	>	UNSAFE.putObjectVolatile(this, headOffset,
789		new PaddedAtomicReference<QNode>(dummy));
790	<	_unsafe.putObjectVolatile(this, tailOffset,
790	>	UNSAFE.putObjectVolatile(this, tailOffset,
791		new PaddedAtomicReference<QNode>(dummy));
792	<	_unsafe.putObjectVolatile(this, cleanMeOffset,
792	>	UNSAFE.putObjectVolatile(this, cleanMeOffset,
793		new PaddedAtomicReference<QNode>(null));
794		}
795
#	Line 814 | Line 819 | public class LinkedTransferQueue<E> exte
819
820		private static long fieldOffset(String fieldName)
821		throws NoSuchFieldException {
822	<	return _unsafe.objectFieldOffset
822	>	return UNSAFE.objectFieldOffset
823		(LinkedTransferQueue.class.getDeclaredField(fieldName));
824		}
825
826	<	private static final Unsafe _unsafe;
826	>	private static final Unsafe UNSAFE;
827		private static final long headOffset;
828		private static final long tailOffset;
829		private static final long cleanMeOffset;
830		static {
831		try {
832	<	_unsafe = getUnsafe();
832	>	UNSAFE = getUnsafe();
833		headOffset = fieldOffset("head");
834		tailOffset = fieldOffset("tail");
835		cleanMeOffset = fieldOffset("cleanMe");

Diff Legend

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