Java concurrency集合之ConcurrentHashMap_动力节点Java学院整理

// 创建一个带有默认初始容量 (16)、加载因子 (0.75) 和 concurrencyLevel (16) 的新的空映射。
ConcurrentHashMap()
// 创建一个带有指定初始容量、默认加载因子 (0.75) 和 concurrencyLevel (16) 的新的空映射。
ConcurrentHashMap(int initialCapacity)
// 创建一个带有指定初始容量、加载因子和默认 concurrencyLevel (16) 的新的空映射。
ConcurrentHashMap(int initialCapacity, float loadFactor)
// 创建一个带有指定初始容量、加载因子和并发级别的新的空映射。
ConcurrentHashMap(int initialCapacity, float loadFactor, int concurrencyLevel)
// 构造一个与给定映射具有相同映射关系的新映射。
ConcurrentHashMap(Map<? extends K,? extends V> m)
// 从该映射中移除所有映射关系
void clear()
// 一种遗留方法，测试此表中是否有一些与指定值存在映射关系的键。
boolean contains(Object value)
// 测试指定对象是否为此表中的键。
boolean containsKey(Object key)
// 如果此映射将一个或多个键映射到指定值，则返回 true。
boolean containsValue(Object value)
// 返回此表中值的枚举。
Enumeration<V> elements()
// 返回此映射所包含的映射关系的 Set 视图。
Set<Map.Entry<K,V>> entrySet()
// 返回指定键所映射到的值，如果此映射不包含该键的映射关系，则返回 null。
V get(Object key)
// 如果此映射不包含键-值映射关系，则返回 true。
boolean isEmpty()
// 返回此表中键的枚举。
Enumeration<K> keys()
// 返回此映射中包含的键的 Set 视图。
Set<K> keySet()
// 将指定键映射到此表中的指定值。
V put(K key, V value)
// 将指定映射中所有映射关系复制到此映射中。
void putAll(Map<? extends K,? extends V> m)
// 如果指定键已经不再与某个值相关联，则将它与给定值关联。
V putIfAbsent(K key, V value)
// 从此映射中移除键（及其相应的值）。
V remove(Object key)
// 只有目前将键的条目映射到给定值时，才移除该键的条目。
boolean remove(Object key, Object value)
// 只有目前将键的条目映射到某一值时，才替换该键的条目。
V replace(K key, V value)
// 只有目前将键的条目映射到给定值时，才替换该键的条目。
boolean replace(K key, V oldValue, V newValue)
// 返回此映射中的键-值映射关系数。
int size()
// 返回此映射中包含的值的 Collection 视图。
Collection<V> values()

@SuppressWarnings("unchecked")
public ConcurrentHashMap(int initialCapacity,
       float loadFactor, int concurrencyLevel) {
 // 参数有效性判断
 if (!(loadFactor > 0) || initialCapacity < 0 || concurrencyLevel <= 0)
  throw new IllegalArgumentException();
 // concurrencyLevel是“用来计算segments的容量”
 if (concurrencyLevel > MAX_SEGMENTS)
  concurrencyLevel = MAX_SEGMENTS;
 int sshift = 0;
 int ssize = 1;
 // ssize=“大于或等于concurrencyLevel的最小的2的N次方值”
 while (ssize < concurrencyLevel) {
  ++sshift;
  ssize <<= 1;
 }
 // 初始化segmentShift和segmentMask
 this.segmentShift = 32 - sshift;
 this.segmentMask = ssize - 1;
 // 哈希表的初始容量
 // 哈希表的实际容量=“segments的容量” x “segments中数组的长度”
 if (initialCapacity > MAXIMUM_CAPACITY)
  initialCapacity = MAXIMUM_CAPACITY;
 // “哈希表的初始容量” / “segments的容量”
 int c = initialCapacity / ssize;
 if (c * ssize < initialCapacity)
  ++c;
 // cap就是“segments中的HashEntry数组的长度”
 int cap = MIN_SEGMENT_TABLE_CAPACITY;
 while (cap < c)
  cap <<= 1;
 // segments
 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;
}

final Segment<K,V>[] segments;

static final class Segment<K,V> extends ReentrantLock implements Serializable {
 ...
 transient volatile HashEntry<K,V>[] table;
 // threshold阈，是哈希表在其容量自动增加之前可以达到多满的一种尺度。
 transient int threshold;
 // loadFactor是加载因子
 final float loadFactor;
 Segment(float lf, int threshold, HashEntry<K,V>[] tab) {
  this.loadFactor = lf;
  this.threshold = threshold;
  this.table = tab;
 }
 ...
}

static final class HashEntry<K,V> {
 final int hash; // 哈希值
 final K key;  // 键
 volatile V value; // 值
 volatile HashEntry<K,V> next; // 下一个HashEntry节点
 HashEntry(int hash, K key, V value, HashEntry<K,V> next) {
  this.hash = hash;
  this.key = key;
  this.value = value;
  this.next = next;
 }
 ..
}

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;
 // 获取key对应的Segment片段。
 // 如果Segment片段不为null，则在“Segment片段的HashEntry数组中”中找到key所对应的HashEntry列表；
 // 接着遍历该HashEntry链表，找到于key-value键值对对应的HashEntry节点。
 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;
}

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);
}

public V put(K key, V value) {
 Segment<K,V> s;
 if (value == null)
  throw new NullPointerException();
 // 获取key对应的哈希值
 int hash = hash(key);
 int j = (hash >>> segmentShift) & segmentMask;
 // 如果找不到该Segment，则新建一个。
 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);
}

final V put(K key, int hash, V value, boolean onlyIfAbsent) {
 // tryLock()获取锁，成功返回true，失败返回false。
 // 获取锁失败的话，则通过scanAndLockForPut()获取锁，并返回”要插入的key-value“对应的”HashEntry链表“。
 HashEntry<K,V> node = tryLock() ? null :
  scanAndLockForPut(key, hash, value);
 V oldValue;
 try {
  // tab代表”当前Segment中的HashEntry数组“
  HashEntry<K,V>[] tab = table;
  // 根据”hash值“获取”HashEntry数组中对应的HashEntry链表“
  int index = (tab.length - 1) & hash;
  HashEntry<K,V> first = entryAt(tab, index);
  for (HashEntry<K,V> e = first;;) {
   // 如果”HashEntry链表中的当前HashEntry节点“不为null，
   if (e != null) {
    K k;
    // 当”要插入的key-value键值对“已经存在于”HashEntry链表中“时，先保存原有的值。
    // 若”onlyIfAbsent“为true，即”要插入的key不存在时才插入”，则直接退出；
    // 否则，用新的value值覆盖原有的原有的值。
    if ((k = e.key) == key ||
     (e.hash == hash && key.equals(k))) {
     oldValue = e.value;
     if (!onlyIfAbsent) {
      e.value = value;
      ++modCount;
     }
     break;
    }
    e = e.next;
   }
   else {
    // 如果node非空，则将first设置为“node的下一个节点”。
    // 否则，新建HashEntry链表
    if (node != null)
     node.setNext(first);
    else
     node = new HashEntry<K,V>(hash, key, value, first);
    int c = count + 1;
    // 如果添加key-value键值对之后，Segment中的元素超过阈值(并且，HashEntry数组的长度没超过限制)，则rehash；
    // 否则，直接添加key-value键值对。
    if (c > threshold && tab.length < MAXIMUM_CAPACITY)
     rehash(node);
    else
     setEntryAt(tab, index, node);
    ++modCount;
    count = c;
    oldValue = null;
    break;
   }
  }
 } finally {
  // 释放锁
  unlock();
 }
 return oldValue;
}

private HashEntry<K,V> scanAndLockForPut(K key, int hash, V value) {
 // 第一个HashEntry节点
 HashEntry<K,V> first = entryForHash(this, hash);
 // 当前的HashEntry节点
 HashEntry<K,V> e = first;
 HashEntry<K,V> node = null;
 // 重复计数(自旋计数器)
 int retries = -1; // negative while locating node
 // 查找”key-value键值对“在”HashEntry链表上对应的节点“；
 // 若找到的话，则不断的自旋；在自旋期间，若通过tryLock()获取锁成功则返回；否则自旋MAX_SCAN_RETRIES次数之后，强制获取”锁“并退出。
 // 若没有找到的话，则新建一个HashEntry链表。然后不断的自旋。
 // 此外，若在自旋期间，HashEntry链表的表头发生变化；则重新进行查找和自旋工作！
 while (!tryLock()) {
  HashEntry<K,V> f; // to recheck first below
  // 1. retries<0的处理情况
  if (retries < 0) {
   // 1.1 如果当前的HashEntry节点为空(意味着，在该HashEntry链表上上没有找到”要插入的键值对“对应的节点)，而且node=null；则新建HashEntry链表。
   if (e == null) {
    if (node == null) // speculatively create node
     node = new HashEntry<K,V>(hash, key, value, null);
    retries = 0;
   }
   // 1.2 如果当前的HashEntry节点是”要插入的键值对在该HashEntry上对应的节点“，则设置retries=0
   else if (key.equals(e.key))
    retries = 0;
   // 1.3 设置为下一个HashEntry。
   else
    e = e.next;
  }
  // 2. 如果自旋次数超过限制，则获取“锁”并退出
  else if (++retries > MAX_SCAN_RETRIES) {
   lock();
   break;
  }
  // 3. 当“尝试了偶数次”时，就获取“当前Segment的第一个HashEntry”，即f。
  // 然后，通过f!=first来判断“当前Segment的第一个HashEntry是否发生了改变”。
  // 若是的话，则重置e，first和retries的值，并重新遍历。
  else if ((retries & 1) == 0 &&
     (f = entryForHash(this, hash)) != first) {
   e = first = f; // re-traverse if entry changed
   retries = -1;
  }
 }
 return node;
}

private void rehash(HashEntry<K,V> node) {
 HashEntry<K,V>[] oldTable = table;
 // ”Segment中原始的HashEntry数组的长度“
 int oldCapacity = oldTable.length;
 // ”Segment中新HashEntry数组的长度“
 int newCapacity = oldCapacity << 1;
 // 新的阈值
 threshold = (int)(newCapacity * loadFactor);
 // 新的HashEntry数组
 HashEntry<K,V>[] newTable =
  (HashEntry<K,V>[]) new HashEntry[newCapacity];
 int sizeMask = newCapacity - 1;
 // 遍历”原始的HashEntry数组“，
 // 将”原始的HashEntry数组“中的每个”HashEntry链表“的值，都复制到”新的HashEntry数组的HashEntry元素“中。
 for (int i = 0; i < oldCapacity ; i++) {
  // 获取”原始的HashEntry数组“中的”第i个HashEntry链表“
  HashEntry<K,V> e = oldTable[i];
  if (e != null) {
   HashEntry<K,V> next = e.next;
   int idx = e.hash & sizeMask;
   if (next == null) // Single node on list
    newTable[idx] = e;
   else { // Reuse consecutive sequence at same slot
    HashEntry<K,V> lastRun = e;
    int lastIdx = idx;
    for (HashEntry<K,V> last = next;
      last != null;
      last = last.next) {
     int k = last.hash & sizeMask;
     if (k != lastIdx) {
      lastIdx = k;
      lastRun = last;
     }
    }
    newTable[lastIdx] = lastRun;
    // 将”原始的HashEntry数组“中的”HashEntry链表(e)“的值，都复制到”新的HashEntry数组的HashEntry“中。
    for (HashEntry<K,V> p = e; p != lastRun; p = p.next) {
     V v = p.value;
     int h = p.hash;
     int k = h & sizeMask;
     HashEntry<K,V> n = newTable[k];
     newTable[k] = new HashEntry<K,V>(h, p.key, v, n);
    }
   }
  }
 }
 // 将新的node节点添加到“Segment的新HashEntry数组(newTable)“中。
 int nodeIndex = node.hash & sizeMask; // add the new node
 node.setNext(newTable[nodeIndex]);
 newTable[nodeIndex] = node;
 table = newTable;
}

static final <K,V> void setEntryAt(HashEntry<K,V>[] tab, int i,
         HashEntry<K,V> e) {
 UNSAFE.putOrderedObject(tab, ((long)i << TSHIFT) + TBASE, e);
}

static final sun.misc.Unsafe UNSAFE;

public native void putOrderedObject(Object o, long offset, Object x);

public V remove(Object key) {
 int hash = hash(key);
 // 根据hash值，找到key对应的Segment片段。
 Segment<K,V> s = segmentForHash(hash);
 return s == null ? null : s.remove(key, hash, null);
}

final V remove(Object key, int hash, Object value) {
 // 尝试获取Segment对应的锁。
 // 尝试失败的话，则通过scanAndLock()来获取锁。
 if (!tryLock())
  scanAndLock(key, hash);
 V oldValue = null;
 try {
  // 根据“hash值”找到“Segment的HashEntry数组”中对应的“HashEntry节点(e)”，该HashEntry节点是一HashEntry个链表。
  HashEntry<K,V>[] tab = table;
  int index = (tab.length - 1) & hash;
  HashEntry<K,V> e = entryAt(tab, index);
  HashEntry<K,V> pred = null;
  // 遍历“HashEntry链表”，删除key-value键值对
  while (e != null) {
   K k;
   HashEntry<K,V> next = e.next;
   if ((k = e.key) == key ||
    (e.hash == hash && key.equals(k))) {
    V v = e.value;
    if (value == null || value == v || value.equals(v)) {
     if (pred == null)
      setEntryAt(tab, index, next);
     else
      pred.setNext(next);
     ++modCount;
     --count;
     oldValue = v;
    }
    break;
   }
   pred = e;
   e = next;
  }
 } finally {
  // 释放锁
  unlock();
 }
 return oldValue;
}

private void scanAndLock(Object key, int hash) {
 // 第一个HashEntry节点
 HashEntry<K,V> first = entryForHash(this, hash);
 HashEntry<K,V> e = first;
 int retries = -1;

// 查找”key-value键值对“在”HashEntry链表上对应的节点“；
 // 无论找没找到，最后都会不断的自旋；在自旋期间，若通过tryLock()获取锁成功则返回；否则自旋MAX_SCAN_RETRIES次数之后，强制获取”锁“并退出。
 // 若在自旋期间，HashEntry链表的表头发生变化；则重新进行查找和自旋！
 while (!tryLock()) {
  HashEntry<K,V> f;
  if (retries < 0) {
   // 如果“遍历完该HashEntry链表，仍然没找到”要删除的键值对“对应的节点”
   // 或者“在该HashEntry链表上找到”要删除的键值对“对应的节点”，则设置retries=0
   // 否则，设置e为下一个HashEntry节点。
   if (e == null || key.equals(e.key))
    retries = 0;
   else
    e = e.next;
  }
  // 自旋超过限制次数之后，获取锁并退出。
  else if (++retries > MAX_SCAN_RETRIES) {
   lock();
   break;
  }
  // 当“尝试了偶数次”时，就获取“当前Segment的第一个HashEntry”，即f。
  // 然后，通过f!=first来判断“当前Segment的第一个HashEntry是否发生了改变”。
  // 若是的话，则重置e，first和retries的值，并重新遍历。
  else if ((retries & 1) == 0 &&
     (f = entryForHash(this, hash)) != first) {
   e = first = f;
   retries = -1;
  }
 }
}

 import java.util.*;
 import java.util.concurrent.*;
 /*
  *  ConcurrentHashMap是“线程安全”的哈希表，而HashMap是非线程安全的。
  *
  *  下面是“多个线程同时操作并且遍历map”的示例
  *  () 当map是ConcurrentHashMap对象时，程序能正常运行。
  *  (02) 当map是HashMap对象时，程序会产生ConcurrentModificationException异常。
 *
 *
 */
 public class ConcurrentHashMapDemo1 {
   // TODO: map是HashMap对象时，程序会出错。
   //private static Map<String, String> map = new HashMap<String, String>();
   private static Map<String, String> map = new ConcurrentHashMap<String, String>();
   public static void main(String[] args) {
     // 同时启动两个线程对map进行操作！
     new MyThread("ta").start();
     new MyThread("tb").start();
   }
   private static void printAll() {
     String key, value;
     Iterator iter = map.entrySet().iterator();
     while(iter.hasNext()) {
       Map.Entry entry = (Map.Entry)iter.next();
       key = (String)entry.getKey();
       value = (String)entry.getValue();
       System.out.print(key+" - "+value+", ");
     }
     System.out.println();
   }
   private static class MyThread extends Thread {
     MyThread(String name) {
       super(name);
     }
     @Override
     public void run() {
         int i = 0;
       while (i++ < 6) {
         // “线程名” + "-" + "序号"
         String val = Thread.currentThread().getName()+i;
         map.put(String.valueOf(i), val);
         // 通过“Iterator”遍历map。
         printAll();
       }
     }
   }
 }

1 - tb1, 
1 - tb1, 
1 - tb1, 1 - tb1, 2 - tb2, 
2 - tb2, 1 - tb1, 
3 - ta3, 1 - tb1, 2 - tb2, 
3 - tb3, 1 - tb1, 2 - tb2, 
3 - tb3, 1 - tb1, 4 - tb4, 3 - tb3, 2 - tb2, 
4 - tb4, 1 - tb1, 2 - tb2, 
5 - ta5, 1 - tb1, 3 - tb3, 5 - tb5, 4 - tb4, 3 - tb3, 2 - tb2, 
4 - tb4, 1 - tb1, 2 - tb2, 
5 - tb5, 1 - tb1, 6 - tb6, 5 - tb5, 3 - tb3, 6 - tb6, 4 - tb4, 3 - tb3, 2 - tb2, 
4 - tb4, 2 - tb2,