--- jsr166/src/jsr166y/LinkedTransferQueue.java	2010/04/05 15:50:51	1.72
+++ jsr166/src/jsr166y/LinkedTransferQueue.java	2010/09/01 22:49:09	1.76
@@ -15,6 +15,7 @@ import java.util.Iterator;
 import java.util.NoSuchElementException;
 import java.util.Queue;
 import java.util.concurrent.locks.LockSupport;
+
 /**
  * An unbounded {@link TransferQueue} based on linked nodes.
  * This queue orders elements FIFO (first-in-first-out) with respect
@@ -321,7 +322,7 @@ public class LinkedTransferQueue<E> exte
      * situations in which we cannot guarantee to make node s
      * unreachable in this way: (1) If s is the trailing node of list
      * (i.e., with null next), then it is pinned as the target node
-     * for appends, so can only be removed later when other nodes are
+     * for appends, so can only be removed later after other nodes are
      * appended. (2) We cannot necessarily unlink s given a
      * predecessor node that is matched (including the case of being
      * cancelled): the predecessor may already be unspliced, in which
@@ -343,18 +344,18 @@ public class LinkedTransferQueue<E> exte
      * When these cases arise, rather than always retraversing the
      * entire list to find an actual predecessor to unlink (which
      * won't help for case (1) anyway), we record a conservative
-     * estimate of possible unsplice failures (in "sweepVotes").  We
-     * trigger a full sweep when the estimate exceeds a threshold
-     * indicating the maximum number of estimated removal failures to
-     * tolerate before sweeping through, unlinking cancelled nodes
-     * that were not unlinked upon initial removal. We perform sweeps
-     * by the thread hitting threshold (rather than background threads
-     * or by spreading work to other threads) because in the main
-     * contexts in which removal occurs, the caller is already
-     * timed-out, cancelled, or performing a potentially O(n)
-     * operation (i.e., remove(x)), none of which are time-critical
-     * enough to warrant the overhead that alternatives would impose
-     * on other threads.
+     * estimate of possible unsplice failures (in "sweepVotes").
+     * We trigger a full sweep when the estimate exceeds a threshold
+     * ("SWEEP_THRESHOLD") indicating the maximum number of estimated
+     * removal failures to tolerate before sweeping through, unlinking
+     * cancelled nodes that were not unlinked upon initial removal.
+     * We perform sweeps by the thread hitting threshold (rather than
+     * background threads or by spreading work to other threads)
+     * because in the main contexts in which removal occurs, the
+     * caller is already timed-out, cancelled, or performing a
+     * potentially O(n) operation (e.g. remove(x)), none of which are
+     * time-critical enough to warrant the overhead that alternatives
+     * would impose on other threads.
      *
      * Because the sweepVotes estimate is conservative, and because
      * nodes become unlinked "naturally" as they fall off the head of
@@ -422,13 +423,13 @@ public class LinkedTransferQueue<E> exte
         }
 
         final boolean casItem(Object cmp, Object val) {
-            assert cmp == null || cmp.getClass() != Node.class;
+            //            assert cmp == null || cmp.getClass() != Node.class;
             return UNSAFE.compareAndSwapObject(this, itemOffset, cmp, val);
         }
 
         /**
-         * Creates a new node. Uses relaxed write because item can only
-         * be seen if followed by CAS.
+         * Constructs a new node.  Uses relaxed write because item can
+         * only be seen after publication via casNext.
          */
         Node(Object item, boolean isData) {
             UNSAFE.putObject(this, itemOffset, item); // relaxed write
@@ -446,7 +447,7 @@ public class LinkedTransferQueue<E> exte
         /**
          * Sets item to self and waiter to null, to avoid garbage
          * retention after matching or cancelling. Uses relaxed writes
-         * bacause order is already constrained in the only calling
+         * because order is already constrained in the only calling
          * contexts: item is forgotten only after volatile/atomic
          * mechanics that extract items.  Similarly, clearing waiter
          * follows either CAS or return from park (if ever parked;
@@ -488,7 +489,7 @@ public class LinkedTransferQueue<E> exte
          * Tries to artificially match a data node -- used by remove.
          */
         final boolean tryMatchData() {
-            assert isData;
+            //            assert isData;
             Object x = item;
             if (x != null && x != this && casItem(x, null)) {
                 LockSupport.unpark(waiter);
@@ -541,7 +542,7 @@ public class LinkedTransferQueue<E> exte
 
     @SuppressWarnings("unchecked")
     static <E> E cast(Object item) {
-        assert item == null || item.getClass() != Node.class;
+        //        assert item == null || item.getClass() != Node.class;
         return (E) item;
     }
 
@@ -656,7 +657,7 @@ public class LinkedTransferQueue<E> exte
         for (;;) {
             Object item = s.item;
             if (item != e) {                  // matched
-                assert item != s;
+                //                assert item != s;
                 s.forgetContents();           // avoid garbage
                 return this.<E>cast(item);
             }