20 |
|
import java.util.ConcurrentModificationException; |
21 |
|
import java.util.NoSuchElementException; |
22 |
|
import java.util.concurrent.ConcurrentMap; |
23 |
+ |
import java.util.concurrent.ThreadLocalRandom; |
24 |
|
import java.util.concurrent.locks.LockSupport; |
25 |
|
import java.io.Serializable; |
26 |
|
|
72 |
|
* versions of this class, constructors may optionally specify an |
73 |
|
* expected {@code concurrencyLevel} as an additional hint for |
74 |
|
* internal sizing. Note that using many keys with exactly the same |
75 |
< |
* {@code hashCode{}} is a sure way to slow down performance of any |
75 |
> |
* {@code hashCode()} is a sure way to slow down performance of any |
76 |
|
* hash table. |
77 |
|
* |
78 |
|
* <p>This class and its views and iterators implement all of the |
352 |
|
* Encodings for special uses of Node hash fields. See above for |
353 |
|
* explanation. |
354 |
|
*/ |
355 |
< |
static final int MOVED = 0x80000000; // hash field for fowarding nodes |
355 |
> |
static final int MOVED = 0x80000000; // hash field for forwarding nodes |
356 |
|
static final int LOCKED = 0x40000000; // set/tested only as a bit |
357 |
|
static final int WAITING = 0xc0000000; // both bits set/tested together |
358 |
|
static final int HASH_BITS = 0x3fffffff; // usable bits of normal node hash |
436 |
|
*/ |
437 |
|
final void tryAwaitLock(Node[] tab, int i) { |
438 |
|
if (tab != null && i >= 0 && i < tab.length) { // bounds check |
439 |
+ |
int r = ThreadLocalRandom.current().nextInt(); // randomize spins |
440 |
|
int spins = MAX_SPINS, h; |
441 |
|
while (tabAt(tab, i) == this && ((h = hash) & LOCKED) != 0) { |
442 |
|
if (spins >= 0) { |
443 |
< |
if (--spins == MAX_SPINS >>> 1) |
444 |
< |
Thread.yield(); // heuristically yield mid-way |
443 |
> |
r ^= r << 1; r ^= r >>> 3; r ^= r << 10; // xorshift |
444 |
> |
if (r >= 0 && --spins == 0) |
445 |
> |
Thread.yield(); // yield before block |
446 |
|
} |
447 |
|
else if (casHash(h, h | WAITING)) { |
448 |
|
synchronized (this) { |
1153 |
|
continue; |
1154 |
|
} |
1155 |
|
else { // transiently use a locked forwarding node |
1156 |
< |
Node g = new Node(MOVED|LOCKED, nextTab, null, null); |
1156 |
> |
Node g = new Node(MOVED|LOCKED, nextTab, null, null); |
1157 |
|
if (!casTabAt(tab, i, f, g)) |
1158 |
|
continue; |
1159 |
|
setTabAt(nextTab, i, null); |
1294 |
|
* |
1295 |
|
* At each step, the iterator snapshots the key ("nextKey") and |
1296 |
|
* value ("nextVal") of a valid node (i.e., one that, at point of |
1297 |
< |
* snapshot, has a nonnull user value). Because val fields can |
1297 |
> |
* snapshot, has a non-null user value). Because val fields can |
1298 |
|
* change (including to null, indicating deletion), field nextVal |
1299 |
|
* might not be accurate at point of use, but still maintains the |
1300 |
|
* weak consistency property of holding a value that was once |
1463 |
|
if (initialCapacity < concurrencyLevel) // Use at least as many bins |
1464 |
|
initialCapacity = concurrencyLevel; // as estimated threads |
1465 |
|
long size = (long)(1.0 + (long)initialCapacity / loadFactor); |
1466 |
< |
int cap = ((size >= (long)MAXIMUM_CAPACITY) ? |
1467 |
< |
MAXIMUM_CAPACITY: tableSizeFor((int)size)); |
1466 |
> |
int cap = ((size >= (long)MAXIMUM_CAPACITY) ? |
1467 |
> |
MAXIMUM_CAPACITY: tableSizeFor((int)size)); |
1468 |
|
this.counter = new LongAdder(); |
1469 |
|
this.sizeCtl = cap; |
1470 |
|
} |
2190 |
|
return true; |
2191 |
|
} |
2192 |
|
|
2193 |
< |
public final boolean removeAll(Collection c) { |
2193 |
> |
public final boolean removeAll(Collection<?> c) { |
2194 |
|
boolean modified = false; |
2195 |
|
for (Iterator<?> it = iter(); it.hasNext();) { |
2196 |
|
if (c.contains(it.next())) { |
2240 |
|
} |
2241 |
|
|
2242 |
|
static final class Values<K,V> extends MapView<K,V> |
2243 |
< |
implements Collection<V> { |
2243 |
> |
implements Collection<V> { |
2244 |
|
Values(ConcurrentHashMapV8<K, V> map) { super(map); } |
2245 |
|
public final boolean contains(Object o) { return map.containsValue(o); } |
2246 |
|
|
2270 |
|
} |
2271 |
|
} |
2272 |
|
|
2273 |
< |
static final class EntrySet<K,V> extends MapView<K,V> |
2273 |
> |
static final class EntrySet<K,V> extends MapView<K,V> |
2274 |
|
implements Set<Map.Entry<K,V>> { |
2275 |
|
EntrySet(ConcurrentHashMapV8<K, V> map) { super(map); } |
2276 |
|
|