| 105 |
|
*/ |
| 106 |
|
public static interface MappingFunction<K, V> { |
| 107 |
|
/** |
| 108 |
< |
* Returns a value for the given key, or null if there is no mapping |
| 108 |
> |
* Returns a value for the given key, or null if there is no mapping. |
| 109 |
|
* |
| 110 |
|
* @param key the (non-null) key |
| 111 |
|
* @return a value for the key, or null if none |
| 145 |
|
* framework. As illustrated here, Spliterators are well suited to |
| 146 |
|
* designs in which a task repeatedly splits off half its work |
| 147 |
|
* into forked subtasks until small enough to process directly, |
| 148 |
< |
* and then joins these subtasks. Variants of this style can be |
| 149 |
< |
* also be used in completion-based designs. |
| 148 |
> |
* and then joins these subtasks. Variants of this style can also |
| 149 |
> |
* be used in completion-based designs. |
| 150 |
|
* |
| 151 |
|
* <pre> |
| 152 |
|
* {@code ConcurrentHashMapV8<String, Long> m = ... |
| 192 |
|
* @return a Spliterator covering approximately half of the |
| 193 |
|
* elements |
| 194 |
|
* @throws IllegalStateException if this Spliterator has |
| 195 |
< |
* already commenced traversing elements. |
| 195 |
> |
* already commenced traversing elements |
| 196 |
|
*/ |
| 197 |
|
Spliterator<T> split(); |
| 198 |
– |
|
| 199 |
– |
/** |
| 200 |
– |
* Returns a Spliterator producing the same elements as this |
| 201 |
– |
* Spliterator. This method may be used for example to create |
| 202 |
– |
* a second Spliterator before a traversal, in order to later |
| 203 |
– |
* perform a second traversal. |
| 204 |
– |
* |
| 205 |
– |
* @return a Spliterator covering the same range as this Spliterator. |
| 206 |
– |
* @throws IllegalStateException if this Spliterator has |
| 207 |
– |
* already commenced traversing elements. |
| 208 |
– |
*/ |
| 209 |
– |
Spliterator<T> clone(); |
| 198 |
|
} |
| 199 |
|
|
| 200 |
|
/* |
| 648 |
|
* TreeBins also maintain a separate locking discipline than |
| 649 |
|
* regular bins. Because they are forwarded via special MOVED |
| 650 |
|
* nodes at bin heads (which can never change once established), |
| 651 |
< |
* we cannot use use those nodes as locks. Instead, TreeBin |
| 651 |
> |
* we cannot use those nodes as locks. Instead, TreeBin |
| 652 |
|
* extends AbstractQueuedSynchronizer to support a simple form of |
| 653 |
|
* read-write lock. For update operations and table validation, |
| 654 |
|
* the exclusive form of lock behaves in the same way as bin-head |
| 794 |
|
} |
| 795 |
|
|
| 796 |
|
/** |
| 797 |
< |
* Find or add a node |
| 797 |
> |
* Finds or adds a node. |
| 798 |
|
* @return null if added |
| 799 |
|
*/ |
| 800 |
|
@SuppressWarnings("unchecked") // suppress Comparable cast warning |
| 2000 |
|
} |
| 2001 |
|
|
| 2002 |
|
/** |
| 2003 |
< |
* Split a normal bin with list headed by e into lo and hi parts; |
| 2004 |
< |
* install in given table |
| 2003 |
> |
* Splits a normal bin with list headed by e into lo and hi parts; |
| 2004 |
> |
* installs in given table. |
| 2005 |
|
*/ |
| 2006 |
|
private static void splitBin(Node[] nextTab, int i, Node e) { |
| 2007 |
|
int bit = nextTab.length >>> 1; // bit to split on |
| 2031 |
|
} |
| 2032 |
|
|
| 2033 |
|
/** |
| 2034 |
< |
* Split a tree bin into lo and hi parts; install in given table |
| 2034 |
> |
* Splits a tree bin into lo and hi parts; installs in given table. |
| 2035 |
|
*/ |
| 2036 |
|
private static void splitTreeBin(Node[] nextTab, int i, TreeBin t) { |
| 2037 |
|
int bit = nextTab.length >>> 1; |
| 2187 |
|
baseLimit = baseSize = (tab == null) ? 0 : tab.length; |
| 2188 |
|
} |
| 2189 |
|
|
| 2190 |
< |
/** Creates iterator for clone() and split() methods */ |
| 2190 |
> |
/** Creates iterator for clone() and split() methods. */ |
| 2191 |
|
InternalIterator(InternalIterator<K,V> it, boolean split) { |
| 2192 |
|
this.map = it.map; |
| 2193 |
|
this.tab = it.tab; |
| 2199 |
|
} |
| 2200 |
|
|
| 2201 |
|
/** |
| 2202 |
< |
* Advances next; returns nextVal or null if terminated |
| 2202 |
> |
* Advances next; returns nextVal or null if terminated. |
| 2203 |
|
* See above for explanation. |
| 2204 |
|
*/ |
| 2205 |
|
final Object advance() { |
| 2249 |
|
/* ---------------- Public operations -------------- */ |
| 2250 |
|
|
| 2251 |
|
/** |
| 2252 |
< |
* Creates a new, empty map with the default initial table size (16), |
| 2252 |
> |
* Creates a new, empty map with the default initial table size (16). |
| 2253 |
|
*/ |
| 2254 |
|
public ConcurrentHashMapV8() { |
| 2255 |
|
this.counter = new LongAdder(); |
| 2330 |
|
if (initialCapacity < concurrencyLevel) // Use at least as many bins |
| 2331 |
|
initialCapacity = concurrencyLevel; // as estimated threads |
| 2332 |
|
long size = (long)(1.0 + (long)initialCapacity / loadFactor); |
| 2333 |
< |
int cap = ((size >= (long)MAXIMUM_CAPACITY) ? |
| 2334 |
< |
MAXIMUM_CAPACITY: tableSizeFor((int)size)); |
| 2333 |
> |
int cap = (size >= (long)MAXIMUM_CAPACITY) ? |
| 2334 |
> |
MAXIMUM_CAPACITY : tableSizeFor((int)size); |
| 2335 |
|
this.counter = new LongAdder(); |
| 2336 |
|
this.sizeCtl = cap; |
| 2337 |
|
} |
| 2940 |
|
|
| 2941 |
|
/** |
| 2942 |
|
* Sets our entry's value and writes through to the map. The |
| 2943 |
< |
* value to return is somewhat arbitrary here. Since a we do |
| 2944 |
< |
* not necessarily track asynchronous changes, the most recent |
| 2943 |
> |
* value to return is somewhat arbitrary here. Since we do not |
| 2944 |
> |
* necessarily track asynchronous changes, the most recent |
| 2945 |
|
* "previous" value could be different from what we return (or |
| 2946 |
|
* could even have been removed in which case the put will |
| 2947 |
|
* re-establish). We do not and cannot guarantee more. |
