ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/jsr166/jsr166/src/extra166y/CustomConcurrentHashMap.java

Comparing jsr166/src/extra166y/CustomConcurrentHashMap.java (file contents):
Revision 1.25 by jsr166, Wed Jan 9 02:51:36 2013 UTC vs.
Revision 1.35 by jsr166, Mon Feb 18 03:15:10 2013 UTC

#	Line 25 | Line 25 | import sun.misc.Unsafe;
25		*   <li> {@linkplain SoftReference Soft}, {@linkplain
26		*        WeakReference weak} or strong (regular) keys and values.
27		*
28	<	*   <li> User-definable <code>MappingFunctions</code> that may be
28	>	*   <li> User-definable {@code MappingFunctions} that may be
29		*        used in method {@link
30		*        CustomConcurrentHashMap#computeIfAbsent} to atomically
31		*        establish a computed value, along with
32	<	*        <code>RemappingFunctions</code> that can be used in method
32	>	*        {@code RemappingFunctions} that can be used in method
33		*        {@link CustomConcurrentHashMap#compute} to atomically
34		*        replace values.
35		*
36	<	*    <li>Factory methods returning specialized forms for <tt>int</tt>
36	>	*    <li>Factory methods returning specialized forms for {@code int}
37		*        keys and/or values, that may be more space-efficient
38		*
39		* </ul>
#	Line 72 | Line 72 | import sun.misc.Unsafe;
72		*
73		* <p>This class also includes nested class {@link KeySet}
74		* that provides space-efficient Set views of maps, also supporting
75	<	* method <code>intern</code>, which may be of use in canonicalizing
75	>	* method {@code intern}, which may be of use in canonicalizing
76		* elements.
77		*
78		* <p>When used with (Weak or Soft) Reference keys and/or values,
79	<	* elements that have asynchronously become <code>null</code> are
79	>	* elements that have asynchronously become {@code null} are
80		* treated as absent from the map and (eventually) removed from maps
81		* via a background thread common across all maps. Because of the
82		* potential for asynchronous clearing of References, methods such as
83	<	* <code>containsValue</code> have weaker guarantees than you might
83	>	* {@code containsValue} have weaker guarantees than you might
84		* expect even in the absence of other explicitly concurrent
85	<	* operations. For example <code>containsValue(value)</code> may
86	<	* return true even if <code>value</code> is no longer available upon
85	>	* operations. For example {@code containsValue(value)} may
86	>	* return true even if {@code value} is no longer available upon
87		* return from the method.
88		*
89		* <p>When Equivalences other than equality are used, the returned
90	<	* collections may violate the specifications of <tt>Map</tt> and/or
91	<	* <tt>Set</tt> interfaces, which mandate the use of the
92	<	* <tt>equals</tt> method when comparing objects.  The methods of this
90	>	* collections may violate the specifications of {@code Map} and/or
91	>	* {@code Set} interfaces, which mandate the use of the
92	>	* {@code equals} method when comparing objects.  The methods of this
93		* class otherwise have properties similar to those of {@link
94		* java.util.ConcurrentHashMap} under its default settings.  To
95		* adaptively maintain semantics and performance under varying
#	Line 110 | Line 110 | import sun.misc.Unsafe;
110		* @param <K> the type of keys maintained by this map
111		* @param <V> the type of mapped values
112		*/
113	<	public class CustomConcurrentHashMap<K, V> extends AbstractMap<K, V>
114	<	implements ConcurrentMap<K, V>, Serializable {
113	>	public class CustomConcurrentHashMap<K,V> extends AbstractMap<K,V>
114	>	implements ConcurrentMap<K,V>, Serializable {
115		private static final long serialVersionUID = 7249069246764182397L;
116
117		/*
#	Line 165 | Line 165 | public class CustomConcurrentHashMap<K,
165		* An object performing equality comparisons, along with a hash
166		* function consistent with this comparison.  The type signatures
167		* of the methods of this interface reflect those of {@link
168	<	* java.util.Map}: While only elements of <code>K</code> may be
169	<	* entered into a Map, any <code>Object</code> may be tested for
168	>	* java.util.Map}: While only elements of {@code K} may be
169	>	* entered into a Map, any {@code Object} may be tested for
170		* membership. Note that the performance of hash maps is heavily
171		* dependent on the quality of hash functions.
172		*/
#	Line 224 | Line 224 | public class CustomConcurrentHashMap<K,
224
225		/**
226		* A function computing a mapping from the given key to a value,
227	<	*  or <code>null</code> if there is no mapping.
227	>	* or {@code null} if there is no mapping.
228		*/
229	<	public static interface MappingFunction<K, V> {
229	>	public static interface MappingFunction<K,V> {
230		/**
231		* Returns a value for the given key, or null if there is no
232		* mapping. If this function throws an (unchecked) exception,
#	Line 244 | Line 244 | public class CustomConcurrentHashMap<K,
244
245		/**
246		* A function computing a new mapping from the given key and its
247	<	* current value to a new value, or <code>null</code> if there is
248	<	* no mapping
247	>	* current value to a new value, or {@code null} if there is
248	>	* no mapping.
249		*/
250	<	public static interface RemappingFunction<K, V> {
250	>	public static interface RemappingFunction<K,V> {
251		/**
252		* Returns a new value for the given key and its current, or
253		* null if there is no mapping.
#	Line 344 | Line 344 | public class CustomConcurrentHashMap<K,
344		* Records the linkage to be returned by the next call to getLinkage.
345		* @param linkage the linkage
346		*/
347	<	void setLinkage(Node r);
347	>	void setLinkage(Node linkage);
348		}
349
350		/**
351		* Each Segment holds a count and table corresponding to a segment
352		* of the table. This class contains only those methods for
353		* directly assigning these fields, which must only be called
354	<	* while holding locks
354	>	* while holding locks.
355		*/
356		static final class Segment extends ReentrantLock {
357		volatile Node[] table;
#	Line 386 | Line 386 | public class CustomConcurrentHashMap<K,
386		}
387
388		/**
389	<	* See the similar code in ConcurrentHashMap for explanation
389	>	* See the similar code in ConcurrentHashMap for explanation.
390		*/
391		final Node[] resizeTable(CustomConcurrentHashMap cchm) {
392		Node[] oldTable = table;
393		if (oldTable == null)
394	<	return table = (Node[])
395	<	new Node[cchm.initialSegmentCapacity];
394	>	return table = new Node[cchm.initialSegmentCapacity];
395
396		int oldCapacity = oldTable.length;
397		if (oldCapacity >= MAX_SEGMENT_CAPACITY)
398		return oldTable;
399	<	Node[] newTable =
401	<	(Node[])new Node[oldCapacity<<1];
399	>	Node[] newTable = new Node[oldCapacity<<1];
400		int sizeMask = newTable.length - 1;
401		NodeFactory fac = cchm.factory;
402		for (int i = 0; i < oldCapacity ; i++) {
#	Line 540 | Line 538 | public class CustomConcurrentHashMap<K,
538		capacity = MAX_SEGMENT_CAPACITY;
539		this.initialSegmentCapacity = capacity;
540		}
541	<	this.segments = (Segment[])new Segment[NSEGMENTS];
541	>	this.segments = new Segment[NSEGMENTS];
542		}
543
544		/**
#	Line 678 | Line 676 | public class CustomConcurrentHashMap<K,
676		}
677
678		/**
679	<	* Returns <tt>true</tt> if this map contains a key equivalent to
679	>	* Returns {@code true} if this map contains a key equivalent to
680		* the given key with respect to this map's key Equivalence.
681		*
682	<	* @param  key   possible key
683	<	* @return <tt>true</tt> if this map contains the specified key
682	>	* @param  key possible key
683	>	* @return {@code true} if this map contains the specified key
684		* @throws NullPointerException if the specified key is null
685		*/
686		public boolean containsKey(Object key) {
#	Line 699 | Line 697 | public class CustomConcurrentHashMap<K,
697		* key with respect to this map's key Equivalence, or {@code null}
698		* if no such mapping exists.
699		*
700	<	* @param  key   possible key
701	<	* @return the value associated with the key or <tt>null</tt> if
702	<	* there is no mapping.
700	>	* @param  key possible key
701	>	* @return the value associated with the key, or {@code null} if
702	>	* there is no mapping
703		* @throws NullPointerException if the specified key is null
704		*/
705		public V get(Object key) {
#	Line 752 | Line 750 | public class CustomConcurrentHashMap<K,
750		*
751		* @param key key with which the specified value is to be associated
752		* @param value value to be associated with the specified key
753	<	* @return the previous value associated with <tt>key</tt>, or
754	<	*         <tt>null</tt> if there was no mapping for <tt>key</tt>
753	>	* @return the previous value associated with {@code key}, or
754	>	*         {@code null} if there was no mapping for {@code key}
755		* @throws NullPointerException if the specified key or value is null
756		*/
757		public V put(K key, V value) {
#	Line 764 | Line 762 | public class CustomConcurrentHashMap<K,
762		* {@inheritDoc}
763		*
764		* @return the previous value associated with the specified key,
765	<	*         or <tt>null</tt> if there was no mapping for the key
765	>	*         or {@code null} if there was no mapping for the key
766		* @throws NullPointerException if the specified key or value is null
767		*/
768		public V putIfAbsent(K key, V value) {
#	Line 813 | Line 811 | public class CustomConcurrentHashMap<K,
811		* {@inheritDoc}
812		*
813		* @return the previous value associated with the specified key,
814	<	*         or <tt>null</tt> if there was no mapping for the key
814	>	*         or {@code null} if there was no mapping for the key
815		* @throws NullPointerException if the specified key or value is null
816		*/
817		public boolean replace(K key, V oldValue, V newValue) {
#	Line 845 | Line 843 | public class CustomConcurrentHashMap<K,
843		* Removes the mapping for the specified key.
844		*
845		* @param  key the key to remove
846	<	* @return the previous value associated with <tt>key</tt>, or
847	<	*         <tt>null</tt> if there was no mapping for <tt>key</tt>
846	>	* @return the previous value associated with {@code key}, or
847	>	*         {@code null} if there was no mapping for {@code key}
848		* @throws NullPointerException if the specified key is null
849		*/
850		public V remove(Object key) {
#	Line 979 | Line 977 | public class CustomConcurrentHashMap<K,
977		}
978
979		/**
980	<	* Returns <tt>true</tt> if this map contains no key-value mappings.
980	>	* Returns {@code true} if this map contains no key-value mappings.
981		*
982	<	* @return <tt>true</tt> if this map contains no key-value mappings
982	>	* @return {@code true} if this map contains no key-value mappings
983		*/
984		public final boolean isEmpty() {
985		final Segment[] segs = this.segments;
#	Line 997 | Line 995 | public class CustomConcurrentHashMap<K,
995
996		/**
997		* Returns the number of key-value mappings in this map.  If the
998	<	* map contains more than <tt>Integer.MAX_VALUE</tt> elements, returns
999	<	* <tt>Integer.MAX_VALUE</tt>.
998	>	* map contains more than {@code Integer.MAX_VALUE} elements, returns
999	>	* {@code Integer.MAX_VALUE}.
1000		*
1001		* @return the number of key-value mappings in this map
1002		*/
#	Line 1014 | Line 1012 | public class CustomConcurrentHashMap<K,
1012		}
1013
1014		/**
1015	<	* Returns <tt>true</tt> if this map maps one or more keys to a
1015	>	* Returns {@code true} if this map maps one or more keys to a
1016		* value equivalent to the given value with respect to this map's
1017		* value Equivalence.  Note: This method requires a full internal
1018		* traversal of the hash table, and so is much slower than method
1019	<	* <tt>containsKey</tt>.
1019	>	* {@code containsKey}.
1020		*
1021		* @param value value whose presence in this map is to be tested
1022	<	* @return <tt>true</tt> if this map maps one or more keys to the
1022	>	* @return {@code true} if this map maps one or more keys to the
1023		*         specified value
1024		* @throws NullPointerException if the specified value is null
1025		*/
#	Line 1091 | Line 1089 | public class CustomConcurrentHashMap<K,
1089		* @param key key with which the specified value is to be associated
1090		* @param mappingFunction the function to compute a value
1091		* @return the current (existing or computed) value associated with
1092	<	*         the specified key, or <tt>null</tt> if the computation
1093	<	*         returned <tt>null</tt>.
1092	>	*         the specified key, or {@code null} if the computation
1093	>	*         returned {@code null}
1094		* @throws NullPointerException if the specified key or mappingFunction
1095	<	*         is null,
1095	>	*         is null
1096		* @throws RuntimeException or Error if the mappingFunction does so,
1097	<	*         in which case the mapping is left unestablished.
1097	>	*         in which case the mapping is left unestablished
1098		*/
1099		public V computeIfAbsent(K key, MappingFunction<? super K, ? extends V> mappingFunction) {
1100		if (key == null || mappingFunction == null)
#	Line 1165 | Line 1163 | public class CustomConcurrentHashMap<K,
1163		* @param key key with which the specified value is to be associated
1164		* @param remappingFunction the function to compute a value
1165		* @return the updated value or
1166	<	*         <tt>null</tt> if the computation returned <tt>null</tt>
1166	>	*         {@code null} if the computation returned {@code null}
1167		* @throws NullPointerException if the specified key or remappingFunction
1168	<	*         is null,
1168	>	*         is null
1169		* @throws RuntimeException or Error if the remappingFunction does so,
1170		*         in which case the mapping is left in its previous state
1171		*/
#	Line 1433 | Line 1431 | public class CustomConcurrentHashMap<K,
1431		* The set is backed by the map, so changes to the map are
1432		* reflected in the set, and vice-versa.  The set supports element
1433		* removal, which removes the corresponding mapping from this map,
1434	<	* via the <tt>Iterator.remove</tt>, <tt>Set.remove</tt>,
1435	<	* <tt>removeAll</tt>, <tt>retainAll</tt>, and <tt>clear</tt>
1436	<	* operations.  It does not support the <tt>add</tt> or
1437	<	* <tt>addAll</tt> operations.
1434	>	* via the {@code Iterator.remove}, {@code Set.remove},
1435	>	* {@code removeAll}, {@code retainAll}, and {@code clear}
1436	>	* operations.  It does not support the {@code add} or
1437	>	* {@code addAll} operations.
1438		*
1439	<	* <p>The view's <tt>iterator</tt> is a "weakly consistent" iterator
1439	>	* <p>The view's {@code iterator} is a "weakly consistent" iterator
1440		* that will never throw {@link ConcurrentModificationException},
1441		* and guarantees to traverse elements as they existed upon
1442		* construction of the iterator, and may (but is not guaranteed to)
#	Line 1454 | Line 1452 | public class CustomConcurrentHashMap<K,
1452		* The collection is backed by the map, so changes to the map are
1453		* reflected in the collection, and vice-versa.  The collection
1454		* supports element removal, which removes the corresponding
1455	<	* mapping from this map, via the <tt>Iterator.remove</tt>,
1456	<	* <tt>Collection.remove</tt>, <tt>removeAll</tt>,
1457	<	* <tt>retainAll</tt>, and <tt>clear</tt> operations.  It does not
1458	<	* support the <tt>add</tt> or <tt>addAll</tt> operations.
1455	>	* mapping from this map, via the {@code Iterator.remove},
1456	>	* {@code Collection.remove}, {@code removeAll},
1457	>	* {@code retainAll}, and {@code clear} operations.  It does not
1458	>	* support the {@code add} or {@code addAll} operations.
1459		*
1460	<	* <p>The view's <tt>iterator</tt> is a "weakly consistent" iterator
1460	>	* <p>The view's {@code iterator} is a "weakly consistent" iterator
1461		* that will never throw {@link ConcurrentModificationException},
1462		* and guarantees to traverse elements as they existed upon
1463		* construction of the iterator, and may (but is not guaranteed to)
#	Line 1475 | Line 1473 | public class CustomConcurrentHashMap<K,
1473		* The set is backed by the map, so changes to the map are
1474		* reflected in the set, and vice-versa.  The set supports element
1475		* removal, which removes the corresponding mapping from the map,
1476	<	* via the <tt>Iterator.remove</tt>, <tt>Set.remove</tt>,
1477	<	* <tt>removeAll</tt>, <tt>retainAll</tt>, and <tt>clear</tt>
1478	<	* operations.  It does not support the <tt>add</tt> or
1479	<	* <tt>addAll</tt> operations.
1476	>	* via the {@code Iterator.remove}, {@code Set.remove},
1477	>	* {@code removeAll}, {@code retainAll}, and {@code clear}
1478	>	* operations.  It does not support the {@code add} or
1479	>	* {@code addAll} operations.
1480		*
1481	<	* <p>The view's <tt>iterator</tt> is a "weakly consistent" iterator
1481	>	* <p>The view's {@code iterator} is a "weakly consistent" iterator
1482		* that will never throw {@link ConcurrentModificationException},
1483		* and guarantees to traverse elements as they existed upon
1484		* construction of the iterator, and may (but is not guaranteed to)
#	Line 1495 | Line 1493 | public class CustomConcurrentHashMap<K,
1493
1494		/**
1495		* Compares the specified object with this map for equality.
1496	<	* Returns <tt>true</tt> if the given object is also a map of the
1496	>	* Returns {@code true} if the given object is also a map of the
1497		* same size, holding keys that are equal using this Map's key
1498		* Equivalence, and which map to values that are equal according
1499		* to this Map's value equivalence.
1500		*
1501		* @param o object to be compared for equality with this map
1502	<	* @return <tt>true</tt> if the specified object is equal to this map
1502	>	* @return {@code true} if the specified object is equal to this map
1503		*/
1504		public boolean equals(Object o) {
1505		if (o == this)
#	Line 1538 | Line 1536 | public class CustomConcurrentHashMap<K,
1536
1537		/**
1538		* Returns the sum of the hash codes of each entry in this map's
1539	<	* <tt>entrySet()</tt> view, which in turn are the hash codes
1539	>	* {@code entrySet()} view, which in turn are the hash codes
1540		* computed using key and value Equivalences for this Map.
1541		* @return the hash code
1542		*/
#	Line 1576 | Line 1574 | public class CustomConcurrentHashMap<K,
1574		private void readObject(java.io.ObjectInputStream s)
1575		throws IOException, ClassNotFoundException {
1576		s.defaultReadObject();
1577	<	this.segments = (Segment[])(new Segment[NSEGMENTS]);
1577	>	this.segments = new Segment[NSEGMENTS];
1578		for (;;) {
1579		K key = (K) s.readObject();
1580		V value = (V) s.readObject();
#	Line 1588 | Line 1586 | public class CustomConcurrentHashMap<K,
1586
1587		/**
1588		* A hash-based set with properties identical to those of
1589	<	* <code>Collections.newSetFromMap</code> applied to a
1590	<	* <code>CustomConcurrentHashMap</code>, but possibly more
1589	>	* {@code Collections.newSetFromMap} applied to a
1590	>	* {@code CustomConcurrentHashMap}, but possibly more
1591		* space-efficient.  The set does not permit null elements. The
1592		* set is serializable; however, serializing a set that uses soft
1593		* or weak references can give unpredictable results.
#	Line 1629 | Line 1627 | public class CustomConcurrentHashMap<K,
1627		}
1628
1629		/**
1630	<	* Returns <tt>true</tt> if this set contains an
1630	>	* Returns {@code true} if this set contains an
1631		* element equivalent to the given element with respect
1632		* to this set's Equivalence.
1633		* @param o element whose presence in this set is to be tested
1634	<	* @return <tt>true</tt> if this set contains the specified element
1634	>	* @return {@code true} if this set contains the specified element
1635		*/
1636		public boolean contains(Object o) {
1637		return cchm.containsKey(o);
#	Line 1656 | Line 1654 | public class CustomConcurrentHashMap<K,
1654		* respect to this set's Equivalence.
1655		*
1656		* @param e element to be added to this set
1657	<	* @return <tt>true</tt> if this set did not already contain
1657	>	* @return {@code true} if this set did not already contain
1658		* the specified element
1659		*/
1660		public boolean add(K e) {
#	Line 1668 | Line 1666 | public class CustomConcurrentHashMap<K,
1666		* respect to this set's Equivalence, if one is present.
1667		*
1668		* @param o object to be removed from this set, if present
1669	<	* @return <tt>true</tt> if the set contained the specified element
1669	>	* @return {@code true} if the set contained the specified element
1670		*/
1671		public boolean remove(Object o) {
1672		return cchm.remove(o) != null;
1673		}
1674
1675		/**
1676	<	* Returns <tt>true</tt> if this set contains no elements.
1676	>	* Returns {@code true} if this set contains no elements.
1677		*
1678	<	* @return <tt>true</tt> if this set contains no elements
1678	>	* @return {@code true} if this set contains no elements
1679		*/
1680		public boolean isEmpty() {
1681		return cchm.isEmpty();
#	Line 1722 | Line 1720 | public class CustomConcurrentHashMap<K,
1720		* to {@link java.lang.ref.Reference} constructors to arrange
1721		* removal of reclaimed nodes from maps via a background thread.
1722		* @return the reference queue associated with the background
1723	<	* cleanup thread.
1723	>	* cleanup thread
1724		*/
1725		static ReferenceQueue<Object> getReclamationQueue() {
1726		ReferenceQueue<Object> q = refQueue;
#	Line 1793 | Line 1791 | public class CustomConcurrentHashMap<K,
1791
1792		// Strong Keys
1793
1794	<	static abstract class StrongKeyNode implements Node {
1794	>	abstract static class StrongKeyNode implements Node {
1795		final Object key;
1796		final int locator;
1797		StrongKeyNode(int locator, Object key) {
#	Line 1805 | Line 1803 | public class CustomConcurrentHashMap<K,
1803		}
1804
1805
1806	<	static abstract class StrongKeySelfValueNode
1806	>	abstract static class StrongKeySelfValueNode
1807		extends StrongKeyNode {
1808		StrongKeySelfValueNode(int locator, Object key) {
1809		super(locator, key);
#	Line 1821 | Line 1819 | public class CustomConcurrentHashMap<K,
1819		super(locator, key);
1820		}
1821		public final Node getLinkage() { return null; }
1822	<	public final void setLinkage(Node r) { }
1822	>	public final void setLinkage(Node linkage) { }
1823		}
1824
1825		static final class LinkedStrongKeySelfValueNode
#	Line 1833 | Line 1831 | public class CustomConcurrentHashMap<K,
1831		this.linkage = linkage;
1832		}
1833		public final Node getLinkage() { return linkage; }
1834	<	public final void setLinkage(Node r) { linkage = r; }
1834	>	public final void setLinkage(Node linkage) { this.linkage = linkage; }
1835		}
1836
1837		static final class StrongKeySelfValueNodeFactory
#	Line 1852 | Line 1850 | public class CustomConcurrentHashMap<K,
1850		}
1851		}
1852
1853	<	static abstract class StrongKeyStrongValueNode
1853	>	abstract static class StrongKeyStrongValueNode
1854		extends StrongKeyNode {
1855		volatile Object value;
1856		StrongKeyStrongValueNode(int locator, Object key, Object value) {
#	Line 1871 | Line 1869 | public class CustomConcurrentHashMap<K,
1869		super(locator, key, value);
1870		}
1871		public final Node getLinkage() { return null; }
1872	<	public final void setLinkage(Node r) { }
1872	>	public final void setLinkage(Node linkage) { }
1873		}
1874
1875		static final class LinkedStrongKeyStrongValueNode
#	Line 1884 | Line 1882 | public class CustomConcurrentHashMap<K,
1882		this.linkage = linkage;
1883		}
1884		public final Node getLinkage() { return linkage; }
1885	<	public final void setLinkage(Node r) { linkage = r; }
1885	>	public final void setLinkage(Node linkage) { this.linkage = linkage; }
1886		}
1887
1888		static final class StrongKeyStrongValueNodeFactory
#	Line 1905 | Line 1903 | public class CustomConcurrentHashMap<K,
1903
1904		// ...
1905
1906	<	static abstract class StrongKeyIntValueNode
1906	>	abstract static class StrongKeyIntValueNode
1907		extends StrongKeyNode {
1908		volatile int value;
1909		StrongKeyIntValueNode(int locator, Object key, Object value) {
#	Line 1926 | Line 1924 | public class CustomConcurrentHashMap<K,
1924		super(locator, key, value);
1925		}
1926		public final Node getLinkage() { return null; }
1927	<	public final void setLinkage(Node r) { }
1927	>	public final void setLinkage(Node linkage) { }
1928		}
1929
1930		static final class LinkedStrongKeyIntValueNode
#	Line 1939 | Line 1937 | public class CustomConcurrentHashMap<K,
1937		this.linkage = linkage;
1938		}
1939		public final Node getLinkage() { return linkage; }
1940	<	public final void setLinkage(Node r) { linkage = r; }
1940	>	public final void setLinkage(Node linkage) { this.linkage = linkage; }
1941		}
1942
1943		static final class StrongKeyIntValueNodeFactory
#	Line 1960 | Line 1958 | public class CustomConcurrentHashMap<K,
1958
1959		// ...
1960
1961	<	static abstract class StrongKeyWeakValueNode
1961	>	abstract static class StrongKeyWeakValueNode
1962		extends StrongKeyNode {
1963		volatile EmbeddedWeakReference valueRef;
1964		final CustomConcurrentHashMap cchm;
#	Line 1994 | Line 1992 | public class CustomConcurrentHashMap<K,
1992		super(locator, key, value, cchm);
1993		}
1994		public final Node getLinkage() { return null; }
1995	<	public final void setLinkage(Node r) { }
1995	>	public final void setLinkage(Node linkage) { }
1996		}
1997
1998		static final class LinkedStrongKeyWeakValueNode
#	Line 2008 | Line 2006 | public class CustomConcurrentHashMap<K,
2006		this.linkage = linkage;
2007		}
2008		public final Node getLinkage() { return linkage; }
2009	<	public final void setLinkage(Node r) { linkage = r; }
2009	>	public final void setLinkage(Node linkage) { this.linkage = linkage; }
2010		}
2011
2012		static final class StrongKeyWeakValueNodeFactory
#	Line 2028 | Line 2026 | public class CustomConcurrentHashMap<K,
2026		}
2027
2028
2029	<	static abstract class StrongKeySoftValueNode
2029	>	abstract static class StrongKeySoftValueNode
2030		extends StrongKeyNode {
2031		volatile EmbeddedSoftReference valueRef;
2032		final CustomConcurrentHashMap cchm;
#	Line 2062 | Line 2060 | public class CustomConcurrentHashMap<K,
2060		super(locator, key, value, cchm);
2061		}
2062		public final Node getLinkage() { return null; }
2063	<	public final void setLinkage(Node r) { }
2063	>	public final void setLinkage(Node linkage) { }
2064		}
2065
2066		static final class LinkedStrongKeySoftValueNode
#	Line 2076 | Line 2074 | public class CustomConcurrentHashMap<K,
2074		this.linkage = linkage;
2075		}
2076		public final Node getLinkage() { return linkage; }
2077	<	public final void setLinkage(Node r) { linkage = r; }
2077	>	public final void setLinkage(Node linkage) { this.linkage = linkage; }
2078		}
2079
2080		static final class StrongKeySoftValueNodeFactory
#	Line 2097 | Line 2095 | public class CustomConcurrentHashMap<K,
2095
2096		// Weak keys
2097
2098	<	static abstract class WeakKeyNode extends WeakReference
2098	>	abstract static class WeakKeyNode extends WeakReference
2099		implements Node {
2100		final int locator;
2101		final CustomConcurrentHashMap cchm;
#	Line 2113 | Line 2111 | public class CustomConcurrentHashMap<K,
2111		}
2112		}
2113
2114	<	static abstract class WeakKeySelfValueNode
2114	>	abstract static class WeakKeySelfValueNode
2115		extends WeakKeyNode {
2116		WeakKeySelfValueNode(int locator, Object key,
2117		CustomConcurrentHashMap cchm) {
#	Line 2130 | Line 2128 | public class CustomConcurrentHashMap<K,
2128		super(locator, key, cchm);
2129		}
2130		public final Node getLinkage() { return null; }
2131	<	public final void setLinkage(Node r) { }
2131	>	public final void setLinkage(Node linkage) { }
2132		}
2133
2134		static final class LinkedWeakKeySelfValueNode
#	Line 2143 | Line 2141 | public class CustomConcurrentHashMap<K,
2141		this.linkage = linkage;
2142		}
2143		public final Node getLinkage() { return linkage; }
2144	<	public final void setLinkage(Node r) { linkage = r; }
2144	>	public final void setLinkage(Node linkage) { this.linkage = linkage; }
2145		}
2146
2147		static final class WeakKeySelfValueNodeFactory
#	Line 2163 | Line 2161 | public class CustomConcurrentHashMap<K,
2161		}
2162
2163
2164	<	static abstract class WeakKeyStrongValueNode
2164	>	abstract static class WeakKeyStrongValueNode
2165		extends WeakKeyNode {
2166		volatile Object value;
2167		WeakKeyStrongValueNode(int locator, Object key, Object value,
#	Line 2183 | Line 2181 | public class CustomConcurrentHashMap<K,
2181		super(locator, key, value, cchm);
2182		}
2183		public final Node getLinkage() { return null; }
2184	<	public final void setLinkage(Node r) { }
2184	>	public final void setLinkage(Node linkage) { }
2185		}
2186
2187		static final class LinkedWeakKeyStrongValueNode
#	Line 2197 | Line 2195 | public class CustomConcurrentHashMap<K,
2195		this.linkage = linkage;
2196		}
2197		public final Node getLinkage() { return linkage; }
2198	<	public final void setLinkage(Node r) { linkage = r; }
2198	>	public final void setLinkage(Node linkage) { this.linkage = linkage; }
2199		}
2200
2201		static final class WeakKeyStrongValueNodeFactory
#	Line 2216 | Line 2214 | public class CustomConcurrentHashMap<K,
2214		}
2215		}
2216
2217	<	static abstract class WeakKeyIntValueNode
2217	>	abstract static class WeakKeyIntValueNode
2218		extends WeakKeyNode {
2219		volatile int value;
2220		WeakKeyIntValueNode(int locator, Object key, Object value,
#	Line 2238 | Line 2236 | public class CustomConcurrentHashMap<K,
2236		super(locator, key, value, cchm);
2237		}
2238		public final Node getLinkage() { return null; }
2239	<	public final void setLinkage(Node r) { }
2239	>	public final void setLinkage(Node linkage) { }
2240		}
2241
2242		static final class LinkedWeakKeyIntValueNode
#	Line 2252 | Line 2250 | public class CustomConcurrentHashMap<K,
2250		this.linkage = linkage;
2251		}
2252		public final Node getLinkage() { return linkage; }
2253	<	public final void setLinkage(Node r) { linkage = r; }
2253	>	public final void setLinkage(Node linkage) { this.linkage = linkage; }
2254		}
2255
2256		static final class WeakKeyIntValueNodeFactory
#	Line 2271 | Line 2269 | public class CustomConcurrentHashMap<K,
2269		}
2270		}
2271
2272	<	static abstract class WeakKeyWeakValueNode
2272	>	abstract static class WeakKeyWeakValueNode
2273		extends WeakKeyNode {
2274		volatile EmbeddedWeakReference valueRef;
2275		WeakKeyWeakValueNode(int locator, Object key, Object value,
#	Line 2300 | Line 2298 | public class CustomConcurrentHashMap<K,
2298		super(locator, key, value, cchm);
2299		}
2300		public final Node getLinkage() { return null; }
2301	<	public final void setLinkage(Node r) { }
2301	>	public final void setLinkage(Node linkage) { }
2302		}
2303
2304		static final class LinkedWeakKeyWeakValueNode
#	Line 2314 | Line 2312 | public class CustomConcurrentHashMap<K,
2312		this.linkage = linkage;
2313		}
2314		public final Node getLinkage() { return linkage; }
2315	<	public final void setLinkage(Node r) { linkage = r; }
2315	>	public final void setLinkage(Node linkage) { this.linkage = linkage; }
2316		}
2317
2318		static final class WeakKeyWeakValueNodeFactory
#	Line 2334 | Line 2332 | public class CustomConcurrentHashMap<K,
2332		}
2333
2334
2335	<	static abstract class WeakKeySoftValueNode
2335	>	abstract static class WeakKeySoftValueNode
2336		extends WeakKeyNode {
2337		volatile EmbeddedSoftReference valueRef;
2338		WeakKeySoftValueNode(int locator, Object key, Object value,
#	Line 2363 | Line 2361 | public class CustomConcurrentHashMap<K,
2361		super(locator, key, value, cchm);
2362		}
2363		public final Node getLinkage() { return null; }
2364	<	public final void setLinkage(Node r) { }
2364	>	public final void setLinkage(Node linkage) { }
2365		}
2366
2367		static final class LinkedWeakKeySoftValueNode
#	Line 2377 | Line 2375 | public class CustomConcurrentHashMap<K,
2375		this.linkage = linkage;
2376		}
2377		public final Node getLinkage() { return linkage; }
2378	<	public final void setLinkage(Node r) { linkage = r; }
2378	>	public final void setLinkage(Node linkage) { this.linkage = linkage; }
2379		}
2380
2381		static final class WeakKeySoftValueNodeFactory
#	Line 2398 | Line 2396 | public class CustomConcurrentHashMap<K,
2396
2397		// Soft keys
2398
2399	<	static abstract class SoftKeyNode extends SoftReference
2399	>	abstract static class SoftKeyNode extends SoftReference
2400		implements Node {
2401		final int locator;
2402		final CustomConcurrentHashMap cchm;
#	Line 2414 | Line 2412 | public class CustomConcurrentHashMap<K,
2412		}
2413		}
2414
2415	<	static abstract class SoftKeySelfValueNode
2415	>	abstract static class SoftKeySelfValueNode
2416		extends SoftKeyNode {
2417		SoftKeySelfValueNode(int locator, Object key,
2418		CustomConcurrentHashMap cchm) {
#	Line 2431 | Line 2429 | public class CustomConcurrentHashMap<K,
2429		super(locator, key, cchm);
2430		}
2431		public final Node getLinkage() { return null; }
2432	<	public final void setLinkage(Node r) { }
2432	>	public final void setLinkage(Node linkage) { }
2433		}
2434
2435		static final class LinkedSoftKeySelfValueNode
#	Line 2444 | Line 2442 | public class CustomConcurrentHashMap<K,
2442		this.linkage = linkage;
2443		}
2444		public final Node getLinkage() { return linkage; }
2445	<	public final void setLinkage(Node r) { linkage = r; }
2445	>	public final void setLinkage(Node linkage) { this.linkage = linkage; }
2446		}
2447
2448		static final class SoftKeySelfValueNodeFactory
#	Line 2464 | Line 2462 | public class CustomConcurrentHashMap<K,
2462		}
2463
2464
2465	<	static abstract class SoftKeyStrongValueNode
2465	>	abstract static class SoftKeyStrongValueNode
2466		extends SoftKeyNode {
2467		volatile Object value;
2468		SoftKeyStrongValueNode(int locator, Object key, Object value,
#	Line 2484 | Line 2482 | public class CustomConcurrentHashMap<K,
2482		super(locator, key, value, cchm);
2483		}
2484		public final Node getLinkage() { return null; }
2485	<	public final void setLinkage(Node r) { }
2485	>	public final void setLinkage(Node linkage) { }
2486		}
2487
2488		static final class LinkedSoftKeyStrongValueNode
#	Line 2498 | Line 2496 | public class CustomConcurrentHashMap<K,
2496		this.linkage = linkage;
2497		}
2498		public final Node getLinkage() { return linkage; }
2499	<	public final void setLinkage(Node r) { linkage = r; }
2499	>	public final void setLinkage(Node linkage) { this.linkage = linkage; }
2500		}
2501
2502		static final class SoftKeyStrongValueNodeFactory
#	Line 2517 | Line 2515 | public class CustomConcurrentHashMap<K,
2515		}
2516		}
2517
2518	<	static abstract class SoftKeyIntValueNode
2518	>	abstract static class SoftKeyIntValueNode
2519		extends SoftKeyNode {
2520		volatile int value;
2521		SoftKeyIntValueNode(int locator, Object key, Object value,
#	Line 2539 | Line 2537 | public class CustomConcurrentHashMap<K,
2537		super(locator, key, value, cchm);
2538		}
2539		public final Node getLinkage() { return null; }
2540	<	public final void setLinkage(Node r) { }
2540	>	public final void setLinkage(Node linkage) { }
2541		}
2542
2543		static final class LinkedSoftKeyIntValueNode
#	Line 2553 | Line 2551 | public class CustomConcurrentHashMap<K,
2551		this.linkage = linkage;
2552		}
2553		public final Node getLinkage() { return linkage; }
2554	<	public final void setLinkage(Node r) { linkage = r; }
2554	>	public final void setLinkage(Node linkage) { this.linkage = linkage; }
2555		}
2556
2557		static final class SoftKeyIntValueNodeFactory
#	Line 2572 | Line 2570 | public class CustomConcurrentHashMap<K,
2570		}
2571		}
2572
2573	<	static abstract class SoftKeyWeakValueNode
2573	>	abstract static class SoftKeyWeakValueNode
2574		extends SoftKeyNode {
2575		volatile EmbeddedWeakReference valueRef;
2576		SoftKeyWeakValueNode(int locator, Object key, Object value,
#	Line 2601 | Line 2599 | public class CustomConcurrentHashMap<K,
2599		super(locator, key, value, cchm);
2600		}
2601		public final Node getLinkage() { return null; }
2602	<	public final void setLinkage(Node r) { }
2602	>	public final void setLinkage(Node linkage) { }
2603		}
2604
2605		static final class LinkedSoftKeyWeakValueNode
#	Line 2615 | Line 2613 | public class CustomConcurrentHashMap<K,
2613		this.linkage = linkage;
2614		}
2615		public final Node getLinkage() { return linkage; }
2616	<	public final void setLinkage(Node r) { linkage = r; }
2616	>	public final void setLinkage(Node linkage) { this.linkage = linkage; }
2617		}
2618
2619		static final class SoftKeyWeakValueNodeFactory
#	Line 2635 | Line 2633 | public class CustomConcurrentHashMap<K,
2633		}
2634
2635
2636	<	static abstract class SoftKeySoftValueNode
2636	>	abstract static class SoftKeySoftValueNode
2637		extends SoftKeyNode {
2638		volatile EmbeddedSoftReference valueRef;
2639		SoftKeySoftValueNode(int locator, Object key, Object value,
#	Line 2664 | Line 2662 | public class CustomConcurrentHashMap<K,
2662		super(locator, key, value, cchm);
2663		}
2664		public final Node getLinkage() { return null; }
2665	<	public final void setLinkage(Node r) { }
2665	>	public final void setLinkage(Node linkage) { }
2666		}
2667
2668		static final class LinkedSoftKeySoftValueNode
#	Line 2678 | Line 2676 | public class CustomConcurrentHashMap<K,
2676		this.linkage = linkage;
2677		}
2678		public final Node getLinkage() { return linkage; }
2679	<	public final void setLinkage(Node r) { linkage = r; }
2679	>	public final void setLinkage(Node linkage) { this.linkage = linkage; }
2680		}
2681
2682		static final class SoftKeySoftValueNodeFactory
#	Line 2697 | Line 2695 | public class CustomConcurrentHashMap<K,
2695		}
2696		}
2697
2698	<	static abstract class IntKeyNode implements Node {
2698	>	abstract static class IntKeyNode implements Node {
2699		final int key;
2700		IntKeyNode(int locator, Object key) {
2701		this.key = ((Integer)key).intValue();
#	Line 2707 | Line 2705 | public class CustomConcurrentHashMap<K,
2705		}
2706
2707
2708	<	static abstract class IntKeySelfValueNode
2708	>	abstract static class IntKeySelfValueNode
2709		extends IntKeyNode {
2710		IntKeySelfValueNode(int locator, Object key) {
2711		super(locator, key);
#	Line 2723 | Line 2721 | public class CustomConcurrentHashMap<K,
2721		super(locator, key);
2722		}
2723		public final Node getLinkage() { return null; }
2724	<	public final void setLinkage(Node r) { }
2724	>	public final void setLinkage(Node linkage) { }
2725		}
2726
2727		static final class LinkedIntKeySelfValueNode
#	Line 2735 | Line 2733 | public class CustomConcurrentHashMap<K,
2733		this.linkage = linkage;
2734		}
2735		public final Node getLinkage() { return linkage; }
2736	<	public final void setLinkage(Node r) { linkage = r; }
2736	>	public final void setLinkage(Node linkage) { this.linkage = linkage; }
2737		}
2738
2739		static final class IntKeySelfValueNodeFactory
#	Line 2754 | Line 2752 | public class CustomConcurrentHashMap<K,
2752		}
2753		}
2754
2755	<	static abstract class IntKeyStrongValueNode
2755	>	abstract static class IntKeyStrongValueNode
2756		extends IntKeyNode {
2757		volatile Object value;
2758		IntKeyStrongValueNode(int locator, Object key, Object value) {
#	Line 2773 | Line 2771 | public class CustomConcurrentHashMap<K,
2771		super(locator, key, value);
2772		}
2773		public final Node getLinkage() { return null; }
2774	<	public final void setLinkage(Node r) { }
2774	>	public final void setLinkage(Node linkage) { }
2775		}
2776
2777		static final class LinkedIntKeyStrongValueNode
#	Line 2786 | Line 2784 | public class CustomConcurrentHashMap<K,
2784		this.linkage = linkage;
2785		}
2786		public final Node getLinkage() { return linkage; }
2787	<	public final void setLinkage(Node r) { linkage = r; }
2787	>	public final void setLinkage(Node linkage) { this.linkage = linkage; }
2788		}
2789
2790		static final class IntKeyStrongValueNodeFactory
#	Line 2805 | Line 2803 | public class CustomConcurrentHashMap<K,
2803		}
2804		}
2805
2806	<	static abstract class IntKeyIntValueNode
2806	>	abstract static class IntKeyIntValueNode
2807		extends IntKeyNode {
2808		volatile int value;
2809		IntKeyIntValueNode(int locator, Object key, Object value) {
#	Line 2826 | Line 2824 | public class CustomConcurrentHashMap<K,
2824		super(locator, key, value);
2825		}
2826		public final Node getLinkage() { return null; }
2827	<	public final void setLinkage(Node r) { }
2827	>	public final void setLinkage(Node linkage) { }
2828		}
2829
2830		static final class LinkedIntKeyIntValueNode
#	Line 2839 | Line 2837 | public class CustomConcurrentHashMap<K,
2837		this.linkage = linkage;
2838		}
2839		public final Node getLinkage() { return linkage; }
2840	<	public final void setLinkage(Node r) { linkage = r; }
2840	>	public final void setLinkage(Node linkage) { this.linkage = linkage; }
2841		}
2842
2843		static final class IntKeyIntValueNodeFactory
#	Line 2858 | Line 2856 | public class CustomConcurrentHashMap<K,
2856		}
2857		}
2858
2859	<	static abstract class IntKeyWeakValueNode
2859	>	abstract static class IntKeyWeakValueNode
2860		extends IntKeyNode {
2861		volatile EmbeddedWeakReference valueRef;
2862		final CustomConcurrentHashMap cchm;
#	Line 2892 | Line 2890 | public class CustomConcurrentHashMap<K,
2890		super(locator, key, value, cchm);
2891		}
2892		public final Node getLinkage() { return null; }
2893	<	public final void setLinkage(Node r) { }
2893	>	public final void setLinkage(Node linkage) { }
2894		}
2895
2896		static final class LinkedIntKeyWeakValueNode
#	Line 2906 | Line 2904 | public class CustomConcurrentHashMap<K,
2904		this.linkage = linkage;
2905		}
2906		public final Node getLinkage() { return linkage; }
2907	<	public final void setLinkage(Node r) { linkage = r; }
2907	>	public final void setLinkage(Node linkage) { this.linkage = linkage; }
2908		}
2909
2910		static final class IntKeyWeakValueNodeFactory
#	Line 2926 | Line 2924 | public class CustomConcurrentHashMap<K,
2924		}
2925
2926
2927	<	static abstract class IntKeySoftValueNode
2927	>	abstract static class IntKeySoftValueNode
2928		extends IntKeyNode {
2929		volatile EmbeddedSoftReference valueRef;
2930		final CustomConcurrentHashMap cchm;
#	Line 2960 | Line 2958 | public class CustomConcurrentHashMap<K,
2958		super(locator, key, value, cchm);
2959		}
2960		public final Node getLinkage() { return null; }
2961	<	public final void setLinkage(Node r) { }
2961	>	public final void setLinkage(Node linkage) { }
2962		}
2963
2964		static final class LinkedIntKeySoftValueNode
#	Line 2974 | Line 2972 | public class CustomConcurrentHashMap<K,
2972		this.linkage = linkage;
2973		}
2974		public final Node getLinkage() { return linkage; }
2975	<	public final void setLinkage(Node r) { linkage = r; }
2975	>	public final void setLinkage(Node linkage) { this.linkage = linkage; }
2976		}
2977
2978		static final class IntKeySoftValueNodeFactory
#	Line 3007 | Line 3005 | public class CustomConcurrentHashMap<K,
3005		try {
3006		UNSAFE = getUnsafe();
3007		tableBase = UNSAFE.arrayBaseOffset(Node[].class);
3008	<	int s = UNSAFE.arrayIndexScale(Node[].class);
3009	<	if ((s & (s-1)) != 0)
3008	>	int scale = UNSAFE.arrayIndexScale(Node[].class);
3009	>	if ((scale & (scale - 1)) != 0)
3010		throw new Error("data type scale not a power of two");
3011	<	tableShift = 31 - Integer.numberOfLeadingZeros(s);
3011	>	tableShift = 31 - Integer.numberOfLeadingZeros(scale);
3012		segmentsBase = UNSAFE.arrayBaseOffset(Segment[].class);
3013	<	s = UNSAFE.arrayIndexScale(Segment[].class);
3014	<	if ((s & (s-1)) != 0)
3013	>	scale = UNSAFE.arrayIndexScale(Segment[].class);
3014	>	if ((scale & (scale - 1)) != 0)
3015		throw new Error("data type scale not a power of two");
3016	<	segmentsShift = 31 - Integer.numberOfLeadingZeros(s);
3016	>	segmentsShift = 31 - Integer.numberOfLeadingZeros(scale);
3017		} catch (Throwable e) {
3018		throw new RuntimeException("Could not initialize intrinsics", e);
3019		}

Diff Legend

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