1
2
3
4
5
6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 

public synchronized V get(Object key) {  Entry<?,?> tab[] = table;  int hash = key.hashCode();  int index = (hash & 0x7FFFFFFF) % tab.length;  for (Entry<?,?> e = tab[index] ; e != null ; e = e.next) {  if ((e.hash == hash) && e.key.equals(key)) {  return (V)e.value;  }  }  return null; } public synchronized V put(K key, V value) {  // Make sure the value is not null  if (value == null) {  throw new NullPointerException();  }   // Makes sure the key is not already in the hashtable.  Entry<?,?> tab[] = table;  int hash = key.hashCode();  int index = (hash & 0x7FFFFFFF) % tab.length;  @SuppressWarnings("unchecked")  Entry<K,V> entry = (Entry<K,V>)tab[index];  for(; entry != null ; entry = entry.next) {  if ((entry.hash == hash) && entry.key.equals(key)) {  V old = entry.value;  entry.value = value;  return old;  }  }   addEntry(hash, key, value, index);  return null; } 

1
2
3
4
5
6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 

public ConcurrentHashMap(int initialCapacity,  float loadFactor, int concurrencyLevel) {  if (!(loadFactor > 0) || initialCapacity < 0 || concurrencyLevel <= 0)  throw new IllegalArgumentException();  if (concurrencyLevel > MAX_SEGMENTS)  concurrencyLevel = MAX_SEGMENTS;  // Find power-of-two sizes best matching arguments  int sshift = 0;  int ssize = 1;  while (ssize < concurrencyLevel) {  ++sshift;  ssize <<= 1;  }  this.segmentShift = 32 - sshift;  this.segmentMask = ssize - 1;  if (initialCapacity > MAXIMUM_CAPACITY)  initialCapacity = MAXIMUM_CAPACITY;  int c = initialCapacity / ssize;  if (c * ssize < initialCapacity)  ++c;  int cap = MIN_SEGMENT_TABLE_CAPACITY;  while (cap < c)  cap <<= 1;  // create segments and segments[0]  Segment<K,V> s0 =  new Segment<K,V>(loadFactor, (int)(cap * loadFactor),  (HashEntry<K,V>[])new HashEntry[cap]);  Segment<K,V>[] ss = (Segment<K,V>[])new Segment[ssize];  UNSAFE.putOrderedObject(ss, SBASE, s0); // ordered write of segments[0]  this.segments = ss;  } 

1
2
3
4
5
6 7 8 9 10 11 

public V put(K key, V value) {  Segment<K,V> s;  if (value == null)  throw new NullPointerException();  int hash = hash(key);  int j = (hash >>> segmentShift) & segmentMask;  if ((s = (Segment<K,V>)UNSAFE.getObject // nonvolatile; recheck  (segments, (j << SSHIFT) + SBASE)) == null) // in ensureSegment  s = ensureSegment(j);  return s.put(key, hash, value, false);  } 

1
2
3
4
5
6 7 8 9 10 11 12 13 14 15 16 17 

public V get(Object key) {
        Segment<K,V> s; // manually integrate access methods to reduce overhead
        HashEntry<K,V>[] tab;
 int h = hash(key);  long u = (((h >>> segmentShift) & segmentMask) << SSHIFT) + SBASE;  if ((s = (Segment<K,V>)UNSAFE.getObjectVolatile(segments, u)) != null &&  (tab = s.table) != null) {  for (HashEntry<K,V> e = (HashEntry<K,V>) UNSAFE.getObjectVolatile  (tab, ((long)(((tab.length - 1) & h)) << TSHIFT) + TBASE);  e != null; e = e.next) {  K k;  if ((k = e.key) == key || (e.hash == h && key.equals(k)))  return e.value;  }  }  return null;  } 

1
2
3
4
5
6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 

public int size() {
        // Try a few times to get accurate count. On failure due to
 // continuous async changes in table, resort to locking.  final Segment<K,V>[] segments = this.segments;  int size;  boolean overflow; // true if size overflows 32 bits  long sum; // sum of modCounts  long last = 0L; // previous sum  int retries = -1; // first iteration isn't retry  try {  for (;;) {  if (retries++ == RETRIES_BEFORE_LOCK) {  for (int j = 0; j < segments.length; ++j)  ensureSegment(j).lock(); // force creation  }  sum = 0L;  size = 0;  overflow = false;  for (int j = 0; j < segments.length; ++j) {  Segment<K,V> seg = segmentAt(segments, j);  if (seg != null) {  sum += seg.modCount;  int c = seg.count;  if (c < 0 || (size += c) < 0)  overflow = true;  }  }  if (sum == last)  break;  last = sum;  }  } finally {  if (retries > RETRIES_BEFORE_LOCK) {  for (int j = 0; j < segments.length; ++j)  segmentAt(segments, j).unlock();  }  }  return overflow ? Integer.MAX_VALUE : size;  } 

1
2
3
4
5
6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 

public boolean containsValue(Object value) {
        // Same idea as size()
 if (value == null)  throw new NullPointerException();  final Segment<K,V>[] segments = this.segments;  boolean found = false;  long last = 0;  int retries = -1;  try {  outer: for (;;) {  if (retries++ == RETRIES_BEFORE_LOCK) {  for (int j = 0; j < segments.length; ++j)  ensureSegment(j).lock(); // force creation  }  long hashSum = 0L;  int sum = 0;  for (int j = 0; j < segments.length; ++j) {  HashEntry<K,V>[] tab;  Segment<K,V> seg = segmentAt(segments, j);  if (seg != null && (tab = seg.table) != null) {  for (int i = 0 ; i < tab.length; i++) {  HashEntry<K,V> e;  for (e = entryAt(tab, i); e != null; e = e.next) {  V v = e.value;  if (v != null && value.equals(v)) {  found = true;  break outer;  }  }  }  sum += seg.modCount;  }  }  if (retries > 0 && sum == last)  break;  last = sum;  }  } finally {  if (retries > RETRIES_BEFORE_LOCK) {  for (int j = 0; j < segments.length; ++j)  segmentAt(segments, j).unlock();  }  }  return found;  } 

1
2
3
4
5
6 7 8 9 10 11 12 13 14 15 16 17 18 

private int hash(Object k) {
        int h = hashSeed;

        if ((0 != h) && (k instanceof String)) {  return sun.misc.Hashing.stringHash32((String) k);  }   h ^= k.hashCode();   // Spread bits to regularize both segment and index locations,  // using variant of single-word Wang/Jenkins hash.  h += (h << 15) ^ 0xffffcd7d;  h ^= (h >>> 10);  h += (h << 3);  h ^= (h >>> 6);  h += (h << 2) + (h << 14);  return h ^ (h >>> 16);  } 

1
2
3
4

System.out.println(Integer.parseInt("0001111", 2) & 15);
System.out.println(Integer.parseInt("0011111", 2) & 15); System.out.println(Integer.parseInt("0111111", 2) & 15); System.out.println(Integer.parseInt("1111111", 2) & 15);