ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/extra166y/CustomConcurrentHashMap.java
(Generate patch)

Comparing jsr166/src/extra166y/CustomConcurrentHashMap.java (file contents):
Revision 1.29 by jsr166, Sat Jan 19 21:37:46 2013 UTC vs.
Revision 1.37 by jsr166, Sun Sep 13 16:28:13 2015 UTC

# Line 5 | Line 5
5   */
6  
7   package extra166y;
8 +
9   import java.lang.ref.*;
10   import java.lang.reflect.*;
11   import java.io.*;
# Line 19 | Line 20 | import sun.misc.Unsafe;
20   * user-supplied computational methods for setting and updating
21   * values. In particular: <ul>
22   *
23 < *   <li> Identity-based, Equality-based or User-definable {@link
24 < *        Equivalence}-based comparisons controlling membership.
23 > *   <li>Identity-based, Equality-based or User-definable {@link
24 > *       Equivalence}-based comparisons controlling membership.
25   *
26 < *   <li> {@linkplain SoftReference Soft}, {@linkplain
27 < *        WeakReference weak} or strong (regular) keys and values.
26 > *   <li>{@linkplain SoftReference Soft}, {@linkplain
27 > *       WeakReference weak} or strong (regular) keys and values.
28   *
29 < *   <li> User-definable {@code MappingFunctions} that may be
30 < *        used in method {@link
31 < *        CustomConcurrentHashMap#computeIfAbsent} to atomically
32 < *        establish a computed value, along with
33 < *        {@code RemappingFunctions} that can be used in method
34 < *        {@link CustomConcurrentHashMap#compute} to atomically
35 < *        replace values.
29 > *   <li>User-definable {@code MappingFunctions} that may be
30 > *       used in method {@link
31 > *       CustomConcurrentHashMap#computeIfAbsent} to atomically
32 > *       establish a computed value, along with
33 > *       {@code RemappingFunctions} that can be used in method
34 > *       {@link CustomConcurrentHashMap#compute} to atomically
35 > *       replace values.
36   *
37 < *    <li>Factory methods returning specialized forms for {@code int}
38 < *        keys and/or values, that may be more space-efficient
37 > *   <li>Factory methods returning specialized forms for {@code int}
38 > *       keys and/or values, that may be more space-efficient
39   *
40   * </ul>
41   *
# Line 110 | Line 111 | import sun.misc.Unsafe;
111   * @param <K> the type of keys maintained by this map
112   * @param <V> the type of mapped values
113   */
114 < public class CustomConcurrentHashMap<K, V> extends AbstractMap<K, V>
115 <    implements ConcurrentMap<K, V>, Serializable {
114 > public class CustomConcurrentHashMap<K,V> extends AbstractMap<K,V>
115 >    implements ConcurrentMap<K,V>, Serializable {
116      private static final long serialVersionUID = 7249069246764182397L;
117  
118      /*
# Line 224 | Line 225 | public class CustomConcurrentHashMap<K,
225  
226      /**
227       * A function computing a mapping from the given key to a value,
228 <     *  or {@code null} if there is no mapping.
228 >     * or {@code null} if there is no mapping.
229       */
230 <    public static interface MappingFunction<K, V> {
230 >    public static interface MappingFunction<K,V> {
231          /**
232           * Returns a value for the given key, or null if there is no
233           * mapping. If this function throws an (unchecked) exception,
# Line 245 | Line 246 | public class CustomConcurrentHashMap<K,
246      /**
247       * A function computing a new mapping from the given key and its
248       * current value to a new value, or {@code null} if there is
249 <     * no mapping
249 >     * no mapping.
250       */
251 <    public static interface RemappingFunction<K, V> {
251 >    public static interface RemappingFunction<K,V> {
252          /**
253           * Returns a new value for the given key and its current, or
254           * null if there is no mapping.
# Line 344 | Line 345 | public class CustomConcurrentHashMap<K,
345           * Records the linkage to be returned by the next call to getLinkage.
346           * @param linkage the linkage
347           */
348 <        void setLinkage(Node r);
348 >        void setLinkage(Node linkage);
349      }
350  
351      /**
352       * Each Segment holds a count and table corresponding to a segment
353       * of the table. This class contains only those methods for
354       * directly assigning these fields, which must only be called
355 <     * while holding locks
355 >     * while holding locks.
356       */
357      static final class Segment extends ReentrantLock {
358          volatile Node[] table;
# Line 386 | Line 387 | public class CustomConcurrentHashMap<K,
387          }
388  
389          /**
390 <         * See the similar code in ConcurrentHashMap for explanation
390 >         * See the similar code in ConcurrentHashMap for explanation.
391           */
392          final Node[] resizeTable(CustomConcurrentHashMap cchm) {
393              Node[] oldTable = table;
# Line 679 | Line 680 | public class CustomConcurrentHashMap<K,
680       * Returns {@code true} if this map contains a key equivalent to
681       * the given key with respect to this map's key Equivalence.
682       *
683 <     * @param  key   possible key
683 >     * @param  key possible key
684       * @return {@code true} if this map contains the specified key
685       * @throws NullPointerException if the specified key is null
686       */
# Line 697 | Line 698 | public class CustomConcurrentHashMap<K,
698       * key with respect to this map's key Equivalence, or {@code null}
699       * if no such mapping exists.
700       *
701 <     * @param  key   possible key
702 <     * @return the value associated with the key or {@code null} if
703 <     * there is no mapping.
701 >     * @param  key possible key
702 >     * @return the value associated with the key, or {@code null} if
703 >     * there is no mapping
704       * @throws NullPointerException if the specified key is null
705       */
706      public V get(Object key) {
# Line 1090 | Line 1091 | public class CustomConcurrentHashMap<K,
1091       * @param mappingFunction the function to compute a value
1092       * @return the current (existing or computed) value associated with
1093       *         the specified key, or {@code null} if the computation
1094 <     *         returned {@code null}.
1094 >     *         returned {@code null}
1095       * @throws NullPointerException if the specified key or mappingFunction
1096 <     *         is null,
1096 >     *         is null
1097       * @throws RuntimeException or Error if the mappingFunction does so,
1098 <     *         in which case the mapping is left unestablished.
1098 >     *         in which case the mapping is left unestablished
1099       */
1100      public V computeIfAbsent(K key, MappingFunction<? super K, ? extends V> mappingFunction) {
1101          if (key == null || mappingFunction == null)
# Line 1165 | Line 1166 | public class CustomConcurrentHashMap<K,
1166       * @return the updated value or
1167       *         {@code null} if the computation returned {@code null}
1168       * @throws NullPointerException if the specified key or remappingFunction
1169 <     *         is null,
1169 >     *         is null
1170       * @throws RuntimeException or Error if the remappingFunction does so,
1171       *         in which case the mapping is left in its previous state
1172       */
# Line 1720 | Line 1721 | public class CustomConcurrentHashMap<K,
1721       * to {@link java.lang.ref.Reference} constructors to arrange
1722       * removal of reclaimed nodes from maps via a background thread.
1723       * @return the reference queue associated with the background
1724 <     * cleanup thread.
1724 >     * cleanup thread
1725       */
1726      static ReferenceQueue<Object> getReclamationQueue() {
1727          ReferenceQueue<Object> q = refQueue;
# Line 1819 | Line 1820 | public class CustomConcurrentHashMap<K,
1820              super(locator, key);
1821          }
1822          public final Node getLinkage() { return null; }
1823 <        public final void setLinkage(Node r) { }
1823 >        public final void setLinkage(Node linkage) { }
1824      }
1825  
1826      static final class LinkedStrongKeySelfValueNode
# Line 1831 | Line 1832 | public class CustomConcurrentHashMap<K,
1832              this.linkage = linkage;
1833          }
1834          public final Node getLinkage() { return linkage; }
1835 <        public final void setLinkage(Node r) { linkage = r; }
1835 >        public final void setLinkage(Node linkage) { this.linkage = linkage; }
1836      }
1837  
1838      static final class StrongKeySelfValueNodeFactory
# Line 1869 | Line 1870 | public class CustomConcurrentHashMap<K,
1870              super(locator, key, value);
1871          }
1872          public final Node getLinkage() { return null; }
1873 <        public final void setLinkage(Node r) { }
1873 >        public final void setLinkage(Node linkage) { }
1874      }
1875  
1876      static final class LinkedStrongKeyStrongValueNode
# Line 1882 | Line 1883 | public class CustomConcurrentHashMap<K,
1883              this.linkage = linkage;
1884          }
1885          public final Node getLinkage() { return linkage; }
1886 <        public final void setLinkage(Node r) { linkage = r; }
1886 >        public final void setLinkage(Node linkage) { this.linkage = linkage; }
1887      }
1888  
1889      static final class StrongKeyStrongValueNodeFactory
# Line 1924 | Line 1925 | public class CustomConcurrentHashMap<K,
1925              super(locator, key, value);
1926          }
1927          public final Node getLinkage() { return null; }
1928 <        public final void setLinkage(Node r) { }
1928 >        public final void setLinkage(Node linkage) { }
1929      }
1930  
1931      static final class LinkedStrongKeyIntValueNode
# Line 1937 | Line 1938 | public class CustomConcurrentHashMap<K,
1938              this.linkage = linkage;
1939          }
1940          public final Node getLinkage() { return linkage; }
1941 <        public final void setLinkage(Node r) { linkage = r; }
1941 >        public final void setLinkage(Node linkage) { this.linkage = linkage; }
1942      }
1943  
1944      static final class StrongKeyIntValueNodeFactory
# Line 1992 | Line 1993 | public class CustomConcurrentHashMap<K,
1993              super(locator, key, value, cchm);
1994          }
1995          public final Node getLinkage() { return null; }
1996 <        public final void setLinkage(Node r) { }
1996 >        public final void setLinkage(Node linkage) { }
1997      }
1998  
1999      static final class LinkedStrongKeyWeakValueNode
# Line 2006 | Line 2007 | public class CustomConcurrentHashMap<K,
2007              this.linkage = linkage;
2008          }
2009          public final Node getLinkage() { return linkage; }
2010 <        public final void setLinkage(Node r) { linkage = r; }
2010 >        public final void setLinkage(Node linkage) { this.linkage = linkage; }
2011      }
2012  
2013      static final class StrongKeyWeakValueNodeFactory
# Line 2060 | Line 2061 | public class CustomConcurrentHashMap<K,
2061              super(locator, key, value, cchm);
2062          }
2063          public final Node getLinkage() { return null; }
2064 <        public final void setLinkage(Node r) { }
2064 >        public final void setLinkage(Node linkage) { }
2065      }
2066  
2067      static final class LinkedStrongKeySoftValueNode
# Line 2074 | Line 2075 | public class CustomConcurrentHashMap<K,
2075              this.linkage = linkage;
2076          }
2077          public final Node getLinkage() { return linkage; }
2078 <        public final void setLinkage(Node r) { linkage = r; }
2078 >        public final void setLinkage(Node linkage) { this.linkage = linkage; }
2079      }
2080  
2081      static final class StrongKeySoftValueNodeFactory
# Line 2128 | Line 2129 | public class CustomConcurrentHashMap<K,
2129              super(locator, key, cchm);
2130          }
2131          public final Node getLinkage() { return null; }
2132 <        public final void setLinkage(Node r) { }
2132 >        public final void setLinkage(Node linkage) { }
2133      }
2134  
2135      static final class LinkedWeakKeySelfValueNode
# Line 2141 | Line 2142 | public class CustomConcurrentHashMap<K,
2142              this.linkage = linkage;
2143          }
2144          public final Node getLinkage() { return linkage; }
2145 <        public final void setLinkage(Node r) { linkage = r; }
2145 >        public final void setLinkage(Node linkage) { this.linkage = linkage; }
2146      }
2147  
2148      static final class WeakKeySelfValueNodeFactory
# Line 2181 | Line 2182 | public class CustomConcurrentHashMap<K,
2182              super(locator, key, value, cchm);
2183          }
2184          public final Node getLinkage() { return null; }
2185 <        public final void setLinkage(Node r) { }
2185 >        public final void setLinkage(Node linkage) { }
2186      }
2187  
2188      static final class LinkedWeakKeyStrongValueNode
# Line 2195 | Line 2196 | public class CustomConcurrentHashMap<K,
2196              this.linkage = linkage;
2197          }
2198          public final Node getLinkage() { return linkage; }
2199 <        public final void setLinkage(Node r) { linkage = r; }
2199 >        public final void setLinkage(Node linkage) { this.linkage = linkage; }
2200      }
2201  
2202      static final class WeakKeyStrongValueNodeFactory
# Line 2236 | Line 2237 | public class CustomConcurrentHashMap<K,
2237              super(locator, key, value, cchm);
2238          }
2239          public final Node getLinkage() { return null; }
2240 <        public final void setLinkage(Node r) { }
2240 >        public final void setLinkage(Node linkage) { }
2241      }
2242  
2243      static final class LinkedWeakKeyIntValueNode
# Line 2250 | Line 2251 | public class CustomConcurrentHashMap<K,
2251              this.linkage = linkage;
2252          }
2253          public final Node getLinkage() { return linkage; }
2254 <        public final void setLinkage(Node r) { linkage = r; }
2254 >        public final void setLinkage(Node linkage) { this.linkage = linkage; }
2255      }
2256  
2257      static final class WeakKeyIntValueNodeFactory
# Line 2298 | Line 2299 | public class CustomConcurrentHashMap<K,
2299              super(locator, key, value, cchm);
2300          }
2301          public final Node getLinkage() { return null; }
2302 <        public final void setLinkage(Node r) { }
2302 >        public final void setLinkage(Node linkage) { }
2303      }
2304  
2305      static final class LinkedWeakKeyWeakValueNode
# Line 2312 | Line 2313 | public class CustomConcurrentHashMap<K,
2313              this.linkage = linkage;
2314          }
2315          public final Node getLinkage() { return linkage; }
2316 <        public final void setLinkage(Node r) { linkage = r; }
2316 >        public final void setLinkage(Node linkage) { this.linkage = linkage; }
2317      }
2318  
2319      static final class WeakKeyWeakValueNodeFactory
# Line 2361 | Line 2362 | public class CustomConcurrentHashMap<K,
2362              super(locator, key, value, cchm);
2363          }
2364          public final Node getLinkage() { return null; }
2365 <        public final void setLinkage(Node r) { }
2365 >        public final void setLinkage(Node linkage) { }
2366      }
2367  
2368      static final class LinkedWeakKeySoftValueNode
# Line 2375 | Line 2376 | public class CustomConcurrentHashMap<K,
2376              this.linkage = linkage;
2377          }
2378          public final Node getLinkage() { return linkage; }
2379 <        public final void setLinkage(Node r) { linkage = r; }
2379 >        public final void setLinkage(Node linkage) { this.linkage = linkage; }
2380      }
2381  
2382      static final class WeakKeySoftValueNodeFactory
# Line 2429 | Line 2430 | public class CustomConcurrentHashMap<K,
2430              super(locator, key, cchm);
2431          }
2432          public final Node getLinkage() { return null; }
2433 <        public final void setLinkage(Node r) { }
2433 >        public final void setLinkage(Node linkage) { }
2434      }
2435  
2436      static final class LinkedSoftKeySelfValueNode
# Line 2442 | Line 2443 | public class CustomConcurrentHashMap<K,
2443              this.linkage = linkage;
2444          }
2445          public final Node getLinkage() { return linkage; }
2446 <        public final void setLinkage(Node r) { linkage = r; }
2446 >        public final void setLinkage(Node linkage) { this.linkage = linkage; }
2447      }
2448  
2449      static final class SoftKeySelfValueNodeFactory
# Line 2482 | Line 2483 | public class CustomConcurrentHashMap<K,
2483              super(locator, key, value, cchm);
2484          }
2485          public final Node getLinkage() { return null; }
2486 <        public final void setLinkage(Node r) { }
2486 >        public final void setLinkage(Node linkage) { }
2487      }
2488  
2489      static final class LinkedSoftKeyStrongValueNode
# Line 2496 | Line 2497 | public class CustomConcurrentHashMap<K,
2497              this.linkage = linkage;
2498          }
2499          public final Node getLinkage() { return linkage; }
2500 <        public final void setLinkage(Node r) { linkage = r; }
2500 >        public final void setLinkage(Node linkage) { this.linkage = linkage; }
2501      }
2502  
2503      static final class SoftKeyStrongValueNodeFactory
# Line 2537 | Line 2538 | public class CustomConcurrentHashMap<K,
2538              super(locator, key, value, cchm);
2539          }
2540          public final Node getLinkage() { return null; }
2541 <        public final void setLinkage(Node r) { }
2541 >        public final void setLinkage(Node linkage) { }
2542      }
2543  
2544      static final class LinkedSoftKeyIntValueNode
# Line 2551 | Line 2552 | public class CustomConcurrentHashMap<K,
2552              this.linkage = linkage;
2553          }
2554          public final Node getLinkage() { return linkage; }
2555 <        public final void setLinkage(Node r) { linkage = r; }
2555 >        public final void setLinkage(Node linkage) { this.linkage = linkage; }
2556      }
2557  
2558      static final class SoftKeyIntValueNodeFactory
# Line 2599 | Line 2600 | public class CustomConcurrentHashMap<K,
2600              super(locator, key, value, cchm);
2601          }
2602          public final Node getLinkage() { return null; }
2603 <        public final void setLinkage(Node r) { }
2603 >        public final void setLinkage(Node linkage) { }
2604      }
2605  
2606      static final class LinkedSoftKeyWeakValueNode
# Line 2613 | Line 2614 | public class CustomConcurrentHashMap<K,
2614              this.linkage = linkage;
2615          }
2616          public final Node getLinkage() { return linkage; }
2617 <        public final void setLinkage(Node r) { linkage = r; }
2617 >        public final void setLinkage(Node linkage) { this.linkage = linkage; }
2618      }
2619  
2620      static final class SoftKeyWeakValueNodeFactory
# Line 2662 | Line 2663 | public class CustomConcurrentHashMap<K,
2663              super(locator, key, value, cchm);
2664          }
2665          public final Node getLinkage() { return null; }
2666 <        public final void setLinkage(Node r) { }
2666 >        public final void setLinkage(Node linkage) { }
2667      }
2668  
2669      static final class LinkedSoftKeySoftValueNode
# Line 2676 | Line 2677 | public class CustomConcurrentHashMap<K,
2677              this.linkage = linkage;
2678          }
2679          public final Node getLinkage() { return linkage; }
2680 <        public final void setLinkage(Node r) { linkage = r; }
2680 >        public final void setLinkage(Node linkage) { this.linkage = linkage; }
2681      }
2682  
2683      static final class SoftKeySoftValueNodeFactory
# Line 2721 | Line 2722 | public class CustomConcurrentHashMap<K,
2722              super(locator, key);
2723          }
2724          public final Node getLinkage() { return null; }
2725 <        public final void setLinkage(Node r) { }
2725 >        public final void setLinkage(Node linkage) { }
2726      }
2727  
2728      static final class LinkedIntKeySelfValueNode
# Line 2733 | Line 2734 | public class CustomConcurrentHashMap<K,
2734              this.linkage = linkage;
2735          }
2736          public final Node getLinkage() { return linkage; }
2737 <        public final void setLinkage(Node r) { linkage = r; }
2737 >        public final void setLinkage(Node linkage) { this.linkage = linkage; }
2738      }
2739  
2740      static final class IntKeySelfValueNodeFactory
# Line 2771 | Line 2772 | public class CustomConcurrentHashMap<K,
2772              super(locator, key, value);
2773          }
2774          public final Node getLinkage() { return null; }
2775 <        public final void setLinkage(Node r) { }
2775 >        public final void setLinkage(Node linkage) { }
2776      }
2777  
2778      static final class LinkedIntKeyStrongValueNode
# Line 2784 | Line 2785 | public class CustomConcurrentHashMap<K,
2785              this.linkage = linkage;
2786          }
2787          public final Node getLinkage() { return linkage; }
2788 <        public final void setLinkage(Node r) { linkage = r; }
2788 >        public final void setLinkage(Node linkage) { this.linkage = linkage; }
2789      }
2790  
2791      static final class IntKeyStrongValueNodeFactory
# Line 2824 | Line 2825 | public class CustomConcurrentHashMap<K,
2825              super(locator, key, value);
2826          }
2827          public final Node getLinkage() { return null; }
2828 <        public final void setLinkage(Node r) { }
2828 >        public final void setLinkage(Node linkage) { }
2829      }
2830  
2831      static final class LinkedIntKeyIntValueNode
# Line 2837 | Line 2838 | public class CustomConcurrentHashMap<K,
2838              this.linkage = linkage;
2839          }
2840          public final Node getLinkage() { return linkage; }
2841 <        public final void setLinkage(Node r) { linkage = r; }
2841 >        public final void setLinkage(Node linkage) { this.linkage = linkage; }
2842      }
2843  
2844      static final class IntKeyIntValueNodeFactory
# Line 2890 | Line 2891 | public class CustomConcurrentHashMap<K,
2891              super(locator, key, value, cchm);
2892          }
2893          public final Node getLinkage() { return null; }
2894 <        public final void setLinkage(Node r) { }
2894 >        public final void setLinkage(Node linkage) { }
2895      }
2896  
2897      static final class LinkedIntKeyWeakValueNode
# Line 2904 | Line 2905 | public class CustomConcurrentHashMap<K,
2905              this.linkage = linkage;
2906          }
2907          public final Node getLinkage() { return linkage; }
2908 <        public final void setLinkage(Node r) { linkage = r; }
2908 >        public final void setLinkage(Node linkage) { this.linkage = linkage; }
2909      }
2910  
2911      static final class IntKeyWeakValueNodeFactory
# Line 2958 | Line 2959 | public class CustomConcurrentHashMap<K,
2959              super(locator, key, value, cchm);
2960          }
2961          public final Node getLinkage() { return null; }
2962 <        public final void setLinkage(Node r) { }
2962 >        public final void setLinkage(Node linkage) { }
2963      }
2964  
2965      static final class LinkedIntKeySoftValueNode
# Line 2972 | Line 2973 | public class CustomConcurrentHashMap<K,
2973              this.linkage = linkage;
2974          }
2975          public final Node getLinkage() { return linkage; }
2976 <        public final void setLinkage(Node r) { linkage = r; }
2976 >        public final void setLinkage(Node linkage) { this.linkage = linkage; }
2977      }
2978  
2979      static final class IntKeySoftValueNodeFactory

Diff Legend

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