--- jsr166/src/jsr166e/ConcurrentHashMapV8.java	2013/06/19 17:00:58	1.104
+++ jsr166/src/jsr166e/ConcurrentHashMapV8.java	2013/07/01 19:19:31	1.108
@@ -299,7 +299,7 @@ public class ConcurrentHashMapV8<K,V>
      * because they have negative hash fields and null key and value
      * fields. (These special nodes are either uncommon or transient,
      * so the impact of carrying around some unused fields is
-     * insignficant.)
+     * insignificant.)
      *
      * The table is lazily initialized to a power-of-two size upon the
      * first insertion.  Each bin in the table normally contains a
@@ -462,7 +462,7 @@ public class ConcurrentHashMapV8<K,V>
      *
      * TreeBins also require an additional locking mechanism.  While
      * list traversal is always possible by readers even during
-     * updates, tree traversal is not, mainly beause of tree-rotations
+     * updates, tree traversal is not, mainly because of tree-rotations
      * that may change the root node and/or its linkages.  TreeBins
      * include a simple read-write lock mechanism parasitic on the
      * main bin-synchronization strategy: Structural adjustments
@@ -569,7 +569,7 @@ public class ConcurrentHashMapV8<K,V>
      * Encodings for Node hash fields. See above for explanation.
      */
     static final int MOVED     = 0x8fffffff; // (-1) hash for forwarding nodes
-    static final int TREEBIN   = 0x80000000; // hash for heads of treea
+    static final int TREEBIN   = 0x80000000; // hash for roots of trees
     static final int RESERVED  = 0x80000001; // hash for transient reservations
     static final int HASH_BITS = 0x7fffffff; // usable bits of normal node hash
 
@@ -589,7 +589,7 @@ public class ConcurrentHashMapV8<K,V>
      * Key-value entry.  This class is never exported out as a
      * user-mutable Map.Entry (i.e., one supporting setValue; see
      * MapEntry below), but can be used for read-only traversals used
-     * in bulk tasks.  Subclasses of Node with a negativehash field
+     * in bulk tasks.  Subclasses of Node with a negative hash field
      * are special, and contain null keys and values (but are never
      * exported).  Otherwise, keys and vals are never null.
      */
@@ -2475,7 +2475,7 @@ public class ConcurrentHashMapV8<K,V>
     }
 
     /**
-     * Returns a list on non-TreeNodes replacing those in given list
+     * Returns a list on non-TreeNodes replacing those in given list.
      */
     static <K,V> Node<K,V> untreeify(Node<K,V> b) {
         Node<K,V> hd = null, tl = null;
@@ -2613,7 +2613,7 @@ public class ConcurrentHashMapV8<K,V>
         }
 
         /**
-         * Acquires write lock for tree restructuring
+         * Acquires write lock for tree restructuring.
          */
         private final void lockRoot() {
             if (!U.compareAndSwapInt(this, LOCKSTATE, 0, WRITER))
@@ -2621,14 +2621,14 @@ public class ConcurrentHashMapV8<K,V>
         }
 
         /**
-         * Releases write lock for tree restructuring
+         * Releases write lock for tree restructuring.
          */
         private final void unlockRoot() {
             lockState = 0;
         }
 
         /**
-         * Possibly blocks awaiting root lock
+         * Possibly blocks awaiting root lock.
          */
         private final void contendedLock() {
             boolean waiting = false;
@@ -2653,7 +2653,7 @@ public class ConcurrentHashMapV8<K,V>
 
         /**
          * Returns matching node or null if none. Tries to search
-         * using tree compareisons from root, but continues linear
+         * using tree comparisons from root, but continues linear
          * search when lock not available.
          */
         final Node<K,V> find(int h, Object k) {
@@ -2751,7 +2751,7 @@ public class ConcurrentHashMapV8<K,V>
          * that are accessible independently of lock. So instead we
          * swap the tree linkages.
          *
-         * @return true if now too small so should be untreeified.
+         * @return true if now too small, so should be untreeified
          */
         final boolean removeTreeNode(TreeNode<K,V> p) {
             TreeNode<K,V> next = (TreeNode<K,V>)p.next;
@@ -3146,7 +3146,7 @@ public class ConcurrentHashMapV8<K,V>
 
     /**
      * Base of key, value, and entry Iterators. Adds fields to
-     * Traverser to support iterator.remove
+     * Traverser to support iterator.remove.
      */
     static class BaseIterator<K,V> extends Traverser<K,V> {
         final ConcurrentHashMapV8<K,V> map;
@@ -3498,10 +3498,10 @@ public class ConcurrentHashMapV8<K,V>
      * of all (key, value) pairs
      * @since 1.8
      */
-    public double reduceToDoubleIn(long parallelismThreshold,
-                                   ObjectByObjectToDouble<? super K, ? super V> transformer,
-                                   double basis,
-                                   DoubleByDoubleToDouble reducer) {
+    public double reduceToDouble(long parallelismThreshold,
+                                 ObjectByObjectToDouble<? super K, ? super V> transformer,
+                                 double basis,
+                                 DoubleByDoubleToDouble reducer) {
         if (transformer == null || reducer == null)
             throw new NullPointerException();
         return new MapReduceMappingsToDoubleTask<K,V>
@@ -5986,7 +5986,7 @@ public class ConcurrentHashMapV8<K,V>
     }
 
     /**
-     * Generates initial value for per-thread CounterHashCodes
+     * Generates initial value for per-thread CounterHashCodes.
      */
     static final AtomicInteger counterHashCodeGenerator = new AtomicInteger();